The API Hub MCP provides 337+ tools covering persistent agent memory, AI-powered content tools, security, finance, web/network analysis, data conversion, math, colors, dates, and more.
🧠 Persistent Memory
Store, search, and retrieve data across agent sessions (agent_memory, memory_search, memory_list)
🤖 AI-Powered Tools (require wallet credits)
Chat completion, summarize, translate, grammar-fix, paraphrase, TL;DR, rewrite (custom tone/length/audience/format)
Generate headlines, keywords, FAQs, bullet points, quizzes, social posts, hashtags, taglines, slogans, elevator pitches
Sentiment, tone, readability, keyword density, and entity analysis
Simplify, formalize, casualize text; create analogies, metaphors, checklists, pros/cons
Analyze URL content, extract contacts, generate SEO metadata, proofread, research topics
🔐 Security & Encoding
Generate QR codes, secure passwords, UUIDs; hash text (MD5/SHA); Base64 & URL encode/decode; decode JWT; check password strength; calculate string entropy
💰 Finance & Math
Real-time crypto prices & currency conversion (160+ currencies), mortgage calculator
Math expression evaluator, descriptive statistics, matrix operations, correlation, VAT/IBAN validation
🌐 Web & Network
DNS lookup, WHOIS, SSL certificate check, IP geolocation, OG metadata extraction
RSS/Atom feed parser, page size/load check, link checker, meta tag scraper
Arbitrary HTTP client (GET/POST/PUT/DELETE), email verification, phone number parsing
📊 Data & Conversion
CSV ↔ JSON, JSON ↔ YAML, XML → JSON, Markdown ↔ HTML
Number base conversion, unit conversion, timezone/timestamp conversion
JSON prettify/minify/validate, text diff, extract HTML tables, generate random test data
🎨 Colors
Color conversion (hex ↔ RGB), palette generation, WCAG contrast ratio check, color harmony schemes
📝 Text & Dates
Regex tester, language detection, Lorem Ipsum generator, word/character count, word frequency
Date arithmetic, public holidays lookup (GB/US/IE), timezone conversion
💳 Wallet & Health
Create a wallet, check balance, buy credits for AI tools
health tool pings all API Hub endpoints and returns operational status
Plus 300+ REST endpoints accessible via a call_api proxy for even broader coverage.
Get real-time cryptocurrency prices from Binance.
Every AI agent forgets everything between sessions. Memory Vault fixes that.
Persistent cross-session memory for any MCP-compatible agent — Claude Code, Cursor, Windsurf, Codex CLI, Copilot, and 100+ more. Plus 45 utility tools.
AI agents have a fundamental limitation: they're born with amnesia. Every new session is a blank slate. They forget:
✅ What you asked them to do
✅ What they learned about your project
✅ What config/credentials they set up
✅ What they already told another tool
Memory Vault is the first MCP server that gives agents permanent memory. Store once, recall forever. No more "I already told you this."
# Agent says: "I don't remember our previous conversation"
# With Memory Vault: "I remember — here's what we discussed last session"Related MCP server: mcp-services
# Add to your MCP client config:
{
"mcpServers": {
"memory-vault": {
"url": "https://api.gadgethumans.com/mcp"
}
}
}uvx gadgethumans-api-hub-mcppip install gadgethumans-api-hub-mcpThat's it. 46 MCP tools. Instant memory.
Tool | What it does |
| Store/recall/delete persistent data by key. Agents remember across sessions forever. |
| Full-text search across everything you've stored. |
| Browse all stored keys by category. |
| View your vault stats, usage, and upgrade options. |
Session 1: Agent stores "project_config" → KV saves it forever
↓
Session 2 (days later): Agent recalls "project_config" → instant retrieval
↓
Session 100: Agent still remembers. Never forgets.Data never expires. Stored in Cloudflare KV (99.99% durability). Only accessible by your agent.
Category | Tools |
🔐 Security | QR codes, password generator, UUIDs, hash (MD5/SHA256/SHA512), Base64, NanoID, ULID |
💰 Finance | Crypto prices (Binance), currency exchange, mortgage calc, loan calc, investment calc, tax bracket, VAT calc, salary calc, compound interest |
🌤️ Weather | Current weather, 7-day forecast, geocode, reverse geocode, air quality |
🌐 Web | OG metadata, URL analyzer, RSS parser, meta scrape, link checker, page size, HTTP headers |
📡 Network | DNS lookup, reverse DNS, DNSSEC, SSL check, WHOIS, domain age, CDN detect, port check, IP geolocation |
📝 Text | Slugify, case convert, truncate, reverse, shuffle, padding, wrap, indent, remove accents, stopword removal, binary/base conversion |
🎨 Colors | Hex↔RGB↔HSL↔HSV↔CMYK, color palette, contrast check, color harmony, color blindness sim |
📊 Data | CSV↔JSON, JSON↔XML↔YAML, TOML↔JSON, INI↔JSON, TSV↔JSON, diff, merge, flatten, sort, filter, dedupe |
🔢 Math | Fibonacci, prime check, factorial, GCD/LCM, percentage, stats, matrix ops, correlation, quadratic solver, geometry |
🏥 Health | BMI, BMR, TDEE, body fat, calorie burn, macro calc, water intake, heart rate zones, VO₂ max |
📖 Readability | Flesch-Kincaid, Gunning Fog, SMOG, ARI, Dale-Chall, FORCAST, Linsear Write, clarity score |
💻 Code | Complexity analysis, stats, beautify, indent check, comment strip, bracket matching, language detection, TODO finder, SQL format |
🔄 Conversions | Speed, area, volume, pressure, temperature (all units), time, angle, energy, data rate, pixels, bytes |
🔓 Ciphers | Atbash, Caesar, ROT13, Vigenère, Morse code, NATO phonetic, Base32, Base85 |
🌍 Reference | Countries, currencies, languages, HTML entities, HTTP codes, MIME types, emoji list, ASCII table, paper sizes, chemical elements, keyboard layouts |
📅 Dates | Business days, age calculator, week number, season, timezone conversion |
🏃 Fitness | BMI, BMR, TDEE, body fat, ideal weight, calorie burn, macro calc, water intake, sleep calc, pace calc |
Plus 300+ REST endpoints via the call_api proxy tool.
Tier | Price | Requests/day | Memory |
🆓 Free | $0 | 100 | ✅ Persistent |
⭐ Pro | $2.99/mo | 500 | ✅ Unlimited |
🏢 Enterprise | $9.99/mo | Unlimited | ✅ Unlimited |
# Free — no API key
curl "https://api.gadgethumans.com/qr?text=hello%20world"
curl "https://api.gadgethumans.com/password?length=24"
curl "https://api.gadgethumans.com/weather?city=London"
curl "https://api.gadgethumans.com/crypto?symbol=bitcoin"
curl "https://api.gadgethumans.com/dns?domain=example.com"All 300+ endpoints at api.gadgethumans.com
┌─────────────┐ ┌──────────────────────────┐ ┌──────────────┐
│ AI Agent │────→│ Memory Vault MCP │────→│ Cloudflare │
│ (Claude, │ │ api.gadgethumans.com/mcp│ │ Worker + KV │
│ Cursor, │ │ │ │ │
│ Codex, etc)│ │ ┌────────────────────┐ │ │ ┌────────┐ │
│ │ │ │ agent_memory │ │────→│ │ KV │ │
│ │ │ │ memory_search │ │ │ │ Store │ │
│ │ │ │ memory_list │ │ │ └────────┘ │
│ │ │ │ 45 utility tools │ │ │ │
│ │ │ │ call_api (300+ ) │ │ │ ┌────────┐ │
│ │ │ └────────────────────┘ │ │ │REST API│ │
└─────────────┘ └──────────────────────────┘ │ │ 300+ │ │
│ │ routes │ │
│ └────────┘ │
└──────────────┘Resource | Link |
MCP Endpoint |
|
PyPI Package | |
Install |
|
MCP Registry |
|
Glama | |
Smithery | |
Subscribe | |
API Gateway | |
Website |
Works with any MCP-compatible client:
Claude Desktop / Claude Code
Cursor
Windsurf
Codex CLI
GitHub Copilot
Continue.dev
Cline
OpenAI Responses API
Any MCP host
MIT — do what you want. Built with ⚡ by Gadget Humans.
Star this repo if Memory Vault helped your agent remember something important. ⭐
Determine the age range for which text content is appropriate.
Parameters:
text — Text to check age appropriateness for.
min_age — Minimum age filter (default: 0 = no filter).
Inputs: text (required), min_age. Returns: result
Read or write persistent agent memory across sessions.
Agents are stateless — use this to store and retrieve data between
sessions. Data is stored in Cloudflare KV and persists indefinitely.
Parameters:
key — Unique memory key to read or write (e.g. "user_preferences").
value — For action="set": JSON string of the value to store.
For action="get" or action="delete": ignored.
action — One of: "get" (read existing value), "set" (write value),
"delete" (remove the key). Default: "get".
Inputs: key (required), value, action. Returns: result
Convert text to alternating case (AlTeRnAtInG cAsE).
Parameters:
text — Text to convert.
Inputs: text (required). Returns: result
Calculate full amortization schedule with monthly breakdowns.
Parameters:
principal — Loan principal amount.
rate — Annual interest rate (e.g. 5.5 for 5.5%).
term_months — Loan term in months.
Inputs: principal (required), rate (required), term_months (required). Returns: result
Check if two texts are anagrams of each other.
Parameters:
text_a — First text to compare.
text_b — Second text to compare.
Inputs: text_a (required), text_b (required). Returns: result
Calculate Flesch-Kincaid readability score, grade level, and reading ease.
Parameters:
text — Text to analyze for readability.
Inputs: text (required). Returns: result
Analyze the tone, emotion, and sentiment of text with detailed breakdown.
Parameters:
text — Text to analyze for tone.
Inputs: text (required). Returns: result
Analyze any URL and return a structured summary with key points, sentiment, and topics.
Use this to understand what a web page is about without reading it.
Returns title, 2-3 sentence summary, key points, topics, sentiment,
and estimated reading time. Powered by AI — no scraping needed.
Parameters:
url — The full URL to analyze (e.g. "https://example.com/page").
Inputs: url (required). Returns: result
Convert between angle units: degrees, radians, gradians, arcminutes, arcseconds.
Parameters:
value — Angle value.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Convert between area units: sq m, sq ft, sq km, sq mi, acres, hectares.
Parameters:
value — Area value to convert.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Calculate Automated Readability Index (ARI) for text.
Parameters:
text — Text to calculate ARI score for.
Inputs: text (required). Returns: result
Get the complete ASCII table with decimal, hex, binary, and character values.
Parameters:
(no parameters needed)
Inputs: no named parameters. Returns: result
Apply the Atbash cipher (reverse alphabet substitution) to text.
Use this to encode or decode messages using the classical Atbash cipher
where A ↔ Z, B ↔ Y, etc.
Parameters:
text — The text to encode or decode with Atbash.
Inputs: text (required). Returns: result
Calculate auto loan monthly payments and total cost.
Parameters:
car_price — Vehicle purchase price.
down_payment — Down payment amount (default: 0).
rate — Annual interest rate (default: 6.0).
term_months — Loan term in months (default: 60).
trade_in — Trade-in value (default: 0).
Inputs: car_price (required), down_payment, rate, term_months, +1 more. Returns: result
Calculate average grade level across multiple readability formulas.
Parameters:
text — Text to calculate average grade level for.
Inputs: text (required). Returns: result
Convert text to binary or binary to text.
Parameters:
text — Text or binary string to convert.
mode — 'encode' (text->binary) or 'decode'.
Inputs: text (required), mode. Returns: result
Estimate blood alcohol content (BAC) level.
Parameters:
weight — Body weight in kg.
sex — 'male' (default) or 'female'.
drinks — Number of standard drinks consumed (default: 1).
hours — Hours since first drink (default: 0).
drink_type — 'standard' (default), 'beer', 'wine', 'spirit'.
Inputs: weight (required), sex, drinks, hours, +1 more. Returns: result
Calculate Basal Metabolic Rate (BMR) using Mifflin-St Jeor equation.
Parameters:
weight — Weight in kg.
height — Height in cm.
age — Age in years.
sex — 'male' (default) or 'female'.
Inputs: weight (required), height (required), age (required), sex. Returns: result
Estimate body fat percentage using measurements or BMI-based formula.
Parameters:
weight — Weight in kg.
height — Height in cm.
age — Age in years.
sex — 'male' (default) or 'female'.
neck — Neck circumference in cm (optional, for Navy method).
waist — Waist circumference in cm (optional, for Navy method).
hip — Hip circumference in cm (optional, for Navy method, female).
Inputs: weight (required), height (required), age (required), sex, +3 more. Returns: result
Calculate Body Surface Area (BSA) using various formulas.
Parameters:
weight — Weight in kg.
height — Height in cm.
formula — 'mosteller' (default), 'du-bois', or 'haycock'.
Inputs: weight (required), height (required), formula. Returns: result
Calculate bond yield to maturity and current yield.
Parameters:
face_value — Bond face/par value.
price — Current market price.
coupon_rate — Annual coupon rate (e.g. 5.0 for 5%).
years_to_maturity — Years until bond matures.
Inputs: face_value (required), price (required), coupon_rate (required), years_to_maturity (required). Returns: result
Check bracket/parenthesis/brace matching in source code.
Parameters:
code — Source code to check bracket matching in.
Inputs: code (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Convert bytes to human-readable format (B, KB, MB, GB, TB, PB).
Parameters:
bytes — Number of bytes.
precision — Decimal places (default: 2).
Inputs: bytes (required), precision. Returns: result
Encrypt or decrypt text using the Caesar cipher.
Parameters:
text — Text to encrypt or decrypt.
shift — Shift amount (default: 3).
mode — 'encrypt' (default) or 'decrypt'.
Inputs: text (required), shift, mode. Returns: result
Calculate Compound Annual Growth Rate (CAGR).
Parameters:
initial_value — Starting value.
final_value — Ending value.
periods — Number of periods (years).
Inputs: initial_value (required), final_value (required), periods (required). Returns: result
Calculate precise age from a birthdate.
Use this to compute someone's age in years, months, and days, either
as of today or a specified date.
Parameters:
birthdate — Birthdate in ISO format (e.g. "1990-04-15") (required).
as_of — Date to calculate age as of (ISO format). Defaults to
today if empty.
Inputs: birthdate (required), as_of. Returns: result
Calculate BMI (Body Mass Index) from weight and height.
Parameters:
weight — Weight (kg for metric, lbs for imperial).
height — Height (cm for metric, inches for imperial).
unit — 'metric' (default) or 'imperial'.
Inputs: weight (required), height (required), unit. Returns: result
Calculate business days — add/subtract working days from a date.
Use this for project planning, SLA calculations, or any date arithmetic
that should skip weekends.
Parameters:
date — Starting date in ISO format (e.g. "2025-06-07").
Defaults to today if empty.
days — Number of business days to add/subtract (default: 0).
direction — "forward" (add days, default) or "backward" (subtract).
Inputs: date, days, direction. Returns: result
Calculate nCr (combinations) and nPr (permutations) for given values.
Use this for combinatorics and probability calculations.
Parameters:
n — Total number of items (non-negative integer).
r — Number of items to choose/arrange (non-negative integer, ≤ n).
Inputs: n (required), r (required). Returns: result
Calculate Pearson or Spearman correlation between two datasets.
Parameters:
method — 'pearson' (default) or 'spearman'.
x — Comma-separated X values.
y — Comma-separated Y values.
Inputs: x (required), y (required), method. Returns: result
Date arithmetic and difference calculations.
Use this to find days between dates, add/subtract time,
or get date info (weekday, unix timestamp).
Parameters:
op — 'info' (default), 'diff', or 'add'.
date1 — Start date (ISO format, default: today).
date2 — End date (for 'diff' operation).
days — Days to add (for 'add' operation).
months — Months to add (for 'add' operation).
years — Years to add (for 'add' operation).
Inputs: op, date1, date2, days, +2 more. Returns: result
Calculate the great-circle (Haversine) distance between two cities.
Geocodes both cities via Nominatim, then computes the distance in
both kilometres and miles.
Parameters:
from_city — Origin city name (required), e.g. "London".
to_city — Destination city name (required), e.g. "Paris".
Inputs: from_city (required), to_city (required). Returns: result
Calculate Shannon entropy of a string (measure of randomness/information content).
Parameters:
text — String to calculate entropy of.
Inputs: text (required). Returns: result
Estimate calories burned during physical activities.
Parameters:
activity — Activity type: 'running', 'walking', 'cycling', 'swimming', 'yoga', etc.
weight — Body weight in kg.
duration — Duration in minutes.
intensity — 'light', 'moderate' (default), or 'vigorous'.
Inputs: activity (required), weight (required), duration (required), intensity. Returns: result
Capitalize the first letter of each sentence in text.
Parameters:
text — Text to capitalize.
Inputs: text (required). Returns: result
Analyze capitalization usage: uppercase, lowercase, mixed, title case.
Parameters:
text — Text to analyze capitalization in.
Inputs: text (required). Returns: result
Convert formal or stiff text to casual, conversational tone.
Parameters:
text — Text to convert to casual tone.
Inputs: text (required). Returns: result
Detect which CDN or reverse proxy is serving a website.
Parameters:
url — URL to detect CDN for (e.g. 'https://example.com').
Inputs: url (required). Returns: result
Count characters including/excluding spaces and non-printable chars.
Parameters:
text — Text to analyze character count.
Inputs: text (required). Returns: result
Send a chat completion request to DeepSeek V4 Flash through the GadgetHumans proxy. REQUIRES an API key with credits. Get one via wallet_create or wallet_buy.
Use this to get AI responses. Each call costs ~1 credit from your wallet.
Accepts an OpenAI-compatible messages format. Returns response with
content, token usage, and cost estimate.
Parameters:
messages — JSON string of messages array (e.g. '[{"role":"user","content":"Hello"}]').
Must be valid JSON with at least one message.
model — Model to use (default: "deepseek-v4-flash").
temperature — Sampling temperature (0.0-1.0, default: 0.7).
max_tokens — Maximum tokens in response (default: 2000).
api_key — Your wallet API key (starts with 'gh_'). REQUIRED for paid access.
Inputs: messages (required), model, temperature, max_tokens, +1 more. Returns: result
Check WCAG contrast ratio between two colors for accessibility.
Parameters:
foreground — Foreground hex color (without #).
background — Background hex color (without #).
Inputs: foreground (required), background (required). Returns: result
Check all links on a page and report their HTTP status codes.
Parameters:
url — URL to check links on.
Inputs: url (required). Returns: result
Check the size and load time of a web page.
Parameters:
url — URL to check page size of.
Inputs: url (required). Returns: result
Check password strength and return score, crack time estimate, and feedback.
Parameters:
password — Password to evaluate.
Inputs: password (required). Returns: result
Check if a domain has a valid SSL/TLS certificate and is reachable.
Use this to verify a website is serving over HTTPS before
making requests. Returns HTTP status and server info.
Parameters:
domain — Domain to check (e.g. 'example.com').
Inputs: domain (required). Returns: result
Look up chemical elements from the periodic table.
Use this to find atomic number, symbol, weight, melting/boiling points,
electron configuration, and other element properties.
Parameters:
symbol — Element symbol to look up, e.g. "Fe", "Au", "C" (optional).
search — Search term to find elements by name or property (optional).
Provide at least one parameter.
Inputs: symbol, search. Returns: result
Calculate a clarity score for text based on readability metrics.
Parameters:
text — Text to calculate clarity score for.
Inputs: text (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Remove redundant whitespace: extra spaces, tabs, newlines, or all.
Parameters:
text — Text to clean.
mode — 'all' (default), 'spaces', or 'lines'.
Inputs: text (required), mode. Returns: result
Convert CMYK values to hex color.
Parameters:
cyan — Cyan percentage (0-100).
magenta — Magenta percentage (0-100).
yellow — Yellow percentage (0-100).
key — Key/Black percentage (0-100).
Inputs: cyan (required), magenta (required), yellow (required), key (required). Returns: result
Beautify/format source code with proper indentation.
Parameters:
code — Source code to beautify.
language — Programming language (default: 'javascript').
Inputs: code (required), language. Returns: result
Calculate cyclomatic complexity and other code metrics.
Parameters:
code — Source code to analyze complexity of.
language — Programming language (default: 'python').
Inputs: code (required), language. Returns: result
Check and validate code indentation consistency.
Parameters:
code — Source code to check indentation of.
language — Programming language (default: 'python').
Inputs: code (required), language. Returns: result
Minify JavaScript code by removing whitespace and comments.
Parameters:
code — JavaScript source code to minify.
Inputs: code (required). Returns: result
Get code statistics: LOC, comments, blank lines, functions, classes.
Parameters:
code — Source code to analyze.
language — Programming language (optional, auto-detected if empty).
Inputs: code (required), language. Returns: result
Simulate how a color appears with different types of color blindness.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
deficiency — 'deuteranopia' (default), 'protanopia', 'tritanopia', or 'achromatopsia'.
Inputs: hex_color (required), deficiency. Returns: result
Generate color harmony schemes (complementary, triadic, analogous, etc).
Parameters:
color — Base hex color (without #).
scheme — Harmony type.
Inputs: color (required), scheme. Returns: result
Mix two hex colors together with a given ratio.
Parameters:
color_a — First hex color without # (e.g. 'FF0000').
color_b — Second hex color without # (e.g. '0000FF').
ratio — Mix ratio 0.0-1.0 (default: 0.5). 0 = all color_a, 1 = all color_b.
Inputs: color_a (required), color_b (required), ratio. Returns: result
Find the closest named CSS color for a given hex value.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Estimate color temperature (warm/cool) of a hex color.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Generate tints (lighter) and shades (darker) of a base color.
Parameters:
hex_color — Base hex color without # (e.g. '3498db').
steps — Number of tint/shade variants per side (default: 5).
Inputs: hex_color (required), steps. Returns: result
Strip comments from source code.
Parameters:
code — Source code with comments to remove.
language — Programming language (default: 'python').
Inputs: code (required), language. Returns: result
Compare two hash values and return whether they match.
Parameters:
hash1 — First hash value.
hash2 — Second hash value to compare against.
Inputs: hash1 (required), hash2 (required). Returns: result
Compare two products, services, or options and get a structured comparison with verdict.
Use this for buying decisions, feature comparisons, or evaluating
alternatives. Returns pros/cons for each, comparison points across
key aspects, and a final verdict on which is better and why.
Parameters:
item_a — First item to compare (e.g. "Herman Miller Aeron").
item_b — Second item to compare (e.g. "Steelcase Gesture").
Inputs: item_a (required), item_b (required). Returns: result
Find the complementary (opposite) color on the color wheel.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Calculate compound interest growth over time with optional monthly contributions.
Parameters:
principal — Initial principal amount.
rate — Annual interest rate (e.g. 5.0 for 5%).
time — Time period in years.
compound — Compound frequency.
contributions — Optional contribution amount (default: 0).
Inputs: principal (required), rate (required), time (required), compound, +1 more. Returns: result
Convert text between camelCase, PascalCase, snake_case, kebab-case, and more.
Parameters:
text — Text to convert.
style — Target case: 'camel', 'pascal', 'snake', 'kebab', 'upper', 'lower'.
Inputs: text (required), style. Returns: result
Convert a color value between hex and RGB formats.
Use this when working with CSS colors, design systems, or anywhere you need
to translate between hex (#FF0000) and RGB (rgb(255, 0, 0)) representations.
Parameters:
value — The color value to convert (required).
Hex format e.g.: "FF0000" or "#FF0000".
RGB format e.g.: "rgb(255,0,0)" or "255,0,0".
from_format — Source format: "hex" or "rgb" (default: "hex").
to_format — Target format: "hex" or "rgb" (default: "rgb").
Inputs: value (required), from_format, to_format. Returns: result
Parse CSV text into structured JSON array.
Use this to convert CSV data from spreadsheets or exports into
JSON format for programmatic use.
Parameters:
csv — CSV text with header row and data rows.
Inputs: csv (required). Returns: result
Convert between currencies using real-time exchange rates.
Use this for currency conversion, financial calculations, or comparing
prices across different currencies. Supports 160+ currencies including
USD, GBP, EUR, JPY, CAD, AUD, and more.
Parameters:
from_ — Source currency code (default: "USD"). Three-letter ISO code.
to — Target currency code (default: "GBP"). Three-letter ISO code.
amount — Amount to convert (default: 1). Positive number.
Inputs: from_, to, amount. Returns: result
Convert JSON object or array to CSV format.
Use this to transform API responses or structured data into
spreadsheet-compatible CSV format.
Parameters:
json_str — JSON string (object or array of objects) to convert.
Inputs: json_str (required). Returns: result
Convert between HTML and Markdown formats.
Use this to transform web content into clean markdown or
convert markdown to HTML for display.
Parameters:
html — HTML content to convert to markdown (optional).
markdown — Markdown content to convert to HTML (optional).
Provide at least one parameter.
Inputs: html, markdown. Returns: result
Convert numbers between different bases (hex, decimal, octal, binary).
Use this for low-level data inspection, color values, or
memory addresses.
Parameters:
num — The number string to convert.
from_base — Source base (default: 10, range: 2-36).
to_base — Target base (default: 16, range: 2-36).
Inputs: num (required), from_base, to_base. Returns: result
Convert a timestamp between Unix epoch and human-readable date formats.
Use this to translate Unix timestamps (e.g., 1717000000) into ISO 8601
date strings, or convert date strings back to Unix timestamps.
Parameters:
value — The timestamp or date string to convert (required).
Accepts Unix timestamps (seconds since epoch) or various
date string formats like "2025-05-29" or "May 29, 2025".
format — Target output format (default: "iso"). Common values include
"iso", "unix", "rfc2822", etc.
Inputs: value (required), format. Returns: result
Convert timestamps between timezones.
Use this when you need to express times in a different timezone.
Supports common zones: UTC, EST, PST, CET, IST, JST, AEST, etc.
Parameters:
timestamp — ISO date string (default: current time).
from_tz — Source timezone code (default: 'UTC').
to_tz — Target timezone code (default: 'UTC').
Inputs: timestamp, from_tz, to_tz. Returns: result
Convert between measurement units: temperature, length, or weight.
Use this for quick unit conversions without lookup tables.
Supports Celsius/Fahrenheit/Kelvin, meters/feet/inches/km/miles,
and kg/lb/oz/stone.
Parameters:
value — Numeric value to convert.
from_unit — Source unit (e.g. 'c', 'm', 'kg').
to_unit — Target unit (e.g. 'f', 'ft', 'lb').
unit_type — 'temperature' (default), 'length', or 'weight'.
Inputs: value (required), from_unit (required), to_unit (required), unit_type. Returns: result
Count the number of syllables in a word or phrase.
Use this for poetry, readability analysis, or linguistic applications
where syllable count is needed.
Parameters:
text — The word or phrase to count syllables in.
Inputs: text (required). Returns: result
Crawl a website's sitemap and return structured page content.
Parameters:
url — Website URL to crawl.
max_pages — Maximum pages to crawl (default: 10).
Inputs: url (required), max_pages. Returns: result
Create a clear analogy comparing a concept to something familiar.
Parameters:
text — Concept to create an analogy for.
Inputs: text (required). Returns: result
Generate creative metaphors to explain or describe any concept.
Parameters:
text — Concept to create a metaphor for.
Inputs: text (required). Returns: result
Calculate credit card payoff timeline with interest savings.
Parameters:
balance — Current credit card balance.
rate — Annual APR (e.g. 18.9 for 18.9%).
min_payment — Minimum monthly payment (optional).
monthly — Fixed monthly payment amount (optional).
Inputs: balance (required), rate (required), min_payment, monthly. Returns: result
Get cross-currency exchange rates with optional historical date.
Parameters:
from_currency — Source currency code (default: 'USD').
to_currency — Target currency code (default: 'EUR').
amount — Amount to convert (default: 1).
date — Historical date (ISO format, optional). Leave empty for current rate.
Inputs: from_currency, to_currency, amount, date. Returns: result
Calculate Dale-Chall readability score for text.
Parameters:
text — Text to calculate Dale-Chall score for.
Inputs: text (required). Returns: result
Convert between data transfer rate units: bps, Kbps, Mbps, Gbps, Tbps.
Parameters:
value — Data rate value.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Decode a JWT token into its header, payload, and signature parts.
Use this to inspect JWT tokens without verifying signatures.
Returns the header (alg, typ) and payload (claims) decoded from base64.
Parameters:
token — The full JWT token string (3 dot-separated base64 parts).
Inputs: token (required). Returns: result
Remove duplicate entries from an array.
Parameters:
data — JSON array to deduplicate.
key — Deduplication key for objects. Empty for value comparisons.
Inputs: data (required), key. Returns: result
Calculate density, mass, or volume given any two values.
Parameters:
mass — Mass (leave 0 if unknown).
volume — Volume (leave 0 if unknown).
density — Density (leave 0 if unknown).
Inputs: mass, volume, density. Returns: result
Calculate descriptive statistics: mean, median, mode, std dev, min, max, quartiles.
Parameters:
numbers — Comma-separated numbers (e.g. '1,2,3,4,5') or JSON array.
Inputs: numbers (required). Returns: result
Detect the language of provided text with confidence score.
Parameters:
text — Text to detect language of.
Inputs: text (required). Returns: result
Detect the character encoding of a text string.
Parameters:
text — Text to detect encoding of.
Inputs: text (required). Returns: result
Calculate the final price after a discount (percentage or fixed amount).
Parameters:
original — Original price.
discount — Discount amount or percentage.
type — 'percent' (default) or 'fixed'.
Inputs: original (required), discount (required), type. Returns: result
Calculate Euclidean distance between two points in 2D space.
Parameters:
x1 — X coordinate of first point.
y1 — Y coordinate of first point.
x2 — X coordinate of second point.
y2 — Y coordinate of second point.
Inputs: x1 (required), y1 (required), x2 (required), y2 (required). Returns: result
Calculate dividend income: annual, quarterly, monthly payouts.
Parameters:
shares — Number of shares owned.
dividend_per_share — Dividend amount per share per payment.
frequency — Payment frequency: 'quarterly' (default), 'monthly', 'annual'.
Inputs: shares (required), dividend_per_share (required), frequency. Returns: result
Look up DNS records and SSL information for any domain.
Use this to check A, AAAA, MX, NS, TXT, and CNAME records, plus
SSL certificate status and server info. Ideal for domain research,
troubleshooting, and infrastructure verification.
Parameters:
domain — The domain name to query (e.g. "example.com").
Inputs: domain (required). Returns: result
Check if a domain has DNSSEC enabled and validate its chain.
Parameters:
domain — Domain name to check (e.g. 'example.com').
Inputs: domain (required). Returns: result
Look up DNS records for a domain (DNS-based WHOIS alternative).
Use this to find what DNS records a domain has.
Returns A, AAAA, MX, NS, TXT, and CNAME records when available.
Parameters:
domain — Domain name to look up (e.g. 'example.com').
Inputs: domain (required). Returns: result
Estimate domain registration age and expiry information.
Parameters:
domain — Domain name to check (e.g. 'example.com').
Inputs: domain (required). Returns: result
Calculate estimated due date and pregnancy milestones.
Parameters:
last_period — First day of last menstrual period (ISO date).
conception — Conception date (ISO date, optional).
cycle_days — Average cycle length in days (default: 28).
Inputs: last_period, conception, cycle_days. Returns: result
Calculate electrical values using Ohm's Law and power equations.
Parameters:
voltage — Voltage in V (leave 0 if unknown).
current — Current in A (leave 0 if unknown).
resistance — Resistance in Ω (leave 0 if unknown).
power — Power in W (leave 0 if unknown).
Inputs: voltage, current, resistance, power. Returns: result
Check if an email domain is valid, reachable, and not disposable.
Parameters:
email — Email address to check domain of (e.g. 'user@example.com').
Inputs: email (required). Returns: result
Calculate Equated Monthly Installment (EMI) for loans.
Parameters:
principal — Loan principal amount.
rate — Annual interest rate (e.g. 8.5 for 8.5%).
tenure_months — Loan tenure in months.
Inputs: principal (required), rate (required), tenure_months (required). Returns: result
Encode or decode text using Base32 encoding.
Use this for compact, case-insensitive encoding suitable for
human-readable tokens, similar to Base64 but using only A-Z and 2-7.
Parameters:
text — The string to encode or decode (required).
mode — "encode" (text → Base32, default) or "decode" (Base32 → text).
Inputs: text (required), mode. Returns: result
Encode or decode text using Base64.
Use this when you need to encode binary data for text-safe transport
(e.g., in JSON, URLs, or email) or decode previously encoded Base64 data.
Parameters:
text — The string to encode or decode (required).
mode — Operation: "encode" (text → Base64) or "decode" (Base64 → text)
(default: "encode").
Inputs: text (required), mode. Returns: result
Encode or decode text using Base85 (Ascii85) encoding.
Use this for more efficient encoding than Base64 — Base85 encodes
4 bytes as 5 ASCII characters, achieving 25% overhead vs Base64's 33%.
Parameters:
text — The string to encode or decode (required).
mode — "encode" (text → Base85, default) or "decode" (Base85 → text).
Inputs: text (required), mode. Returns: result
Convert between energy units: J, cal, Wh, kWh, BTU, ft-lb, eV.
Parameters:
value — Energy value.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Evaluate a mathematical expression safely.
Parameters:
expression — Math expression string (e.g. '3.14 * 2^10 / (5+3)').
Inputs: expression (required). Returns: result
Expand abbreviations, acronyms, and shorthand into full forms.
Parameters:
text — Text containing abbreviations to expand.
Inputs: text (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Extract email addresses, social media links, and phone numbers from any URL.
Use this for lead generation, finding contact information on company
websites, or researching business contacts. Returns emails, social
links (LinkedIn, Twitter, GitHub, etc.), and phone numbers found
in the page content.
Parameters:
url — The full URL to scan for contacts (e.g. "https://example.com/contact").
Inputs: url (required). Returns: result
Extract named entities (people, places, orgs, dates) from text.
Parameters:
text — Text to extract entities from.
Inputs: text (required). Returns: result
Extract HTML tables into structured JSON array.
Parameters:
html — HTML content containing tables.
Inputs: html (required). Returns: result
Calculate the factorial of a non-negative integer.
Parameters:
n — Non-negative integer to calculate factorial of.
Inputs: n (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Generate the Fibonacci sequence up to the specified count.
Parameters:
count — Number of Fibonacci numbers (default: 10).
Inputs: count. Returns: result
Read or write persistent file storage across sessions (KV-backed).
Parameters:
key — Unique file key (e.g. 'my_document.json').
value — For action='set': file content.
action — 'get' (default), 'set', or 'delete'.
Inputs: key (required), value, action. Returns: result
Filter array items by a condition expression.
Parameters:
data — JSON array to filter.
condition — Filter condition (e.g. 'age > 18').
Inputs: data (required), condition (required). Returns: result
Find words longer than a specified length.
Parameters:
text — Text to search for long words.
min_length — Minimum word length (default: 10).
Inputs: text (required), min_length. Returns: result
Find words shorter than a specified length.
Parameters:
text — Text to search for short words.
max_length — Maximum word length (default: 3).
Inputs: text (required), max_length. Returns: result
Estimate fitness age based on resting heart rate and activity.
Parameters:
resting_hr — Resting heart rate in bpm.
age — Chronological age in years.
activity_freq — Exercise sessions per week (default: 3).
Inputs: resting_hr (required), age (required), activity_freq. Returns: result
Flatten nested JSON to dot-notation key-value pairs.
Parameters:
json_str — JSON string to flatten.
separator — Separator (default: '.').
Inputs: json_str (required), separator. Returns: result
Flip one or more coins and get heads/tails results.
Parameters:
count — Number of coins to flip (default: 1).
Inputs: count. Returns: result
Calculate FORCAST readability grade level (for non-narrative texts).
Parameters:
text — Text to calculate FORCAST score for.
Inputs: text (required). Returns: result
Calculate force, mass, or acceleration using F = ma.
Parameters:
mass — Mass in kg (leave 0 if unknown).
acceleration — Acceleration in m/s² (leave 0 if unknown).
force — Force in N (leave 0 if unknown).
Inputs: mass, acceleration, force. Returns: result
Convert casual or informal text to formal tone.
Parameters:
text — Text to convert to formal tone.
Inputs: text (required). Returns: result
Perform arithmetic operations on fractions (add, subtract, multiply, divide).
Parameters:
operation — 'add', 'subtract', 'multiply', or 'divide'.
numerator1 — First fraction numerator.
denominator1 — First fraction denominator.
numerator2 — Second fraction numerator (default: 0).
denominator2 — Second fraction denominator (default: 1).
Inputs: operation (required), numerator1 (required), denominator1 (required), numerator2, +1 more. Returns: result
Calculate Fry readability graph estimate for text.
Parameters:
text — Text to calculate Fry readability for.
Inputs: text (required). Returns: result
Calculate fuel cost for a journey.
Parameters:
distance — Distance.
efficiency — Fuel efficiency.
price — Price per unit.
unit — 'mpg' (default) or 'kmpl'.
Inputs: distance (required), efficiency (required), price (required), unit. Returns: result
Calculate GCD and LCM of two numbers.
Parameters:
a — First number.
b — Second number.
Inputs: a (required), b (required). Returns: result
Generate a step-by-step checklist from process or task description.
Parameters:
text — Process or task description to create a checklist from.
Inputs: text (required). Returns: result
Generate a harmonious color palette from a base color.
Parameters:
base — Base hex color (without #, e.g. '3498db').
count — Number of colors in the palette (default: 5).
Inputs: base (required), count. Returns: result
Generate relevant hashtags from content for social media.
Parameters:
text — Content to generate hashtags from.
Inputs: text (required). Returns: result
Generate Lorem Ipsum placeholder text.
Use this when creating mockups, wireframes, design drafts, or any situation
where you need realistic-looking placeholder text.
Parameters:
type — Unit of output: "paragraphs", "sentences", or "words"
(default: "paragraphs").
count — Number of units to generate (1-100, default: 3).
Inputs: type, count. Returns: result
Generate Nano ID strings — compact, URL-safe unique identifiers.
Use this for short unique IDs suitable for URLs, tokens, or database keys.
Nano IDs are URL-friendly, collision-resistant, and customizable.
Parameters:
length — Length of each Nano ID (default: 21).
alphabet — Custom alphabet string (optional). Default uses A-Za-z0-9_-.
Inputs: length, alphabet. Returns: result
Generate one or more secure random passwords.
Use this when a user needs a strong, random password — for account creation,
temporary credentials, API keys, or any security-sensitive use case.
Parameters:
length — Length of each password (4-256, default: 16).
count — Number of passwords to generate (1-50, default: 1).
numbers — Include digits 0-9 (default: True).
symbols — Include special characters like !@#$%^&* (default: True).
uppercase — Include A-Z (default: True).
lowercase — Include a-z (default: True).
Inputs: length, count, numbers, symbols, +2 more. Returns: result
Create a compelling elevator pitch from product or business description.
Parameters:
text — Product, service, or business description.
Inputs: text (required). Returns: result
Generate a QR code image and return it as Base64-encoded data.
Use this when you need to encode a URL, text, or other data into a QR code
image that can be displayed or embedded in documents/web pages.
Parameters:
text — The text or URL to encode in the QR code (required).
format — Output image format: "png", "svg", or "gif" (default: "png").
size — Image size in pixels (100-1000, default: 300).
color — Foreground hex color (without #, default: "000000").
bgcolor — Background hex color (without #, default: "FFFFFF").
ecc — Error correction level: "L", "M", "Q", or "H" (default: "M").
Higher levels allow more damage before the code becomes unreadable.
margin — Margin in modules (0-20, default: 4).
Inputs: text (required), format, size, color, +3 more. Returns: result
Generate random data for testing: numbers, strings, booleans, dates, or mixed.
Parameters:
type — Type: 'number', 'string', 'boolean', 'date', or 'mixed'.
count — Number of items to generate (default: 5).
Inputs: type, count. Returns: result
Generate random numbers within a range.
Use this when you need one or more random integers for dice rolls,
lottery numbers, sampling, or any randomized selection.
Parameters:
min — Minimum value (inclusive, default: 0).
max — Maximum value (inclusive, default: 100).
count — How many numbers to generate (default: 1).
unique — Whether numbers must be unique/no repeats (default: False).
Inputs: min, max, count, unique. Returns: result
Generate SEO-optimized title, meta description, keywords, and slug.
Use this when publishing content — get an SEO title (55-60 chars),
meta description (150-160 chars), relevant keywords, and a URL-friendly
slug. Provide a URL to analyze or a topic directly.
Parameters:
url — Optional URL of existing content to base metadata on.
topic — Optional topic/keyword to generate metadata for.
At least one of url or topic is required.
Inputs: url, topic. Returns: result
Generate catchy marketing slogans from brand or product description.
Parameters:
text — Brand or product description.
Inputs: text (required). Returns: result
Generate short, memorable taglines from content or brand description.
Parameters:
text — Brand or content description.
Inputs: text (required). Returns: result
Generate one or more ULIDs (Universally Unique Lexicographically Sortable IDs).
Use this when you need sortable unique identifiers that encode a
timestamp. ULIDs are 26-character, URL-safe, and sortable by creation time.
Parameters:
count — Number of ULIDs to generate (default: 1).
Inputs: count. Returns: result
Generate one or more UUID v4 (random) identifiers.
Use this when you need unique identifiers for database records, API resources,
session IDs, or anywhere a globally unique ID is required.
Parameters:
count — Number of UUIDs to generate (1-100, default: 1).
format — Output format: "standard" (xxxxxxxx-xxxx-...), "json", or "array"
(default: "standard").
Inputs: count, format. Returns: result
Forward geocode an address or place name to coordinates.
Uses Nominatim (free, no key). Returns lat, lon, display_name, type,
and importance for up to 5 results.
Parameters:
query — Address or place name to geocode (required), e.g. "London" or "10 Downing Street".
Inputs: query (required). Returns: result
Get geolocation data for an IP address.
Use this to determine the geographical location, ISP, and timezone associated
with an IP address. Helpful for fraud detection, analytics, geo-targeting,
or debugging network issues.
Parameters:
ip_address — The IP address to look up (e.g., "8.8.8.8").
If empty or omitted, returns data for the requester's own IP.
Inputs: ip_address. Returns: result
Calculate area, perimeter, or volume for common geometric shapes.
Use this for quick geometry math — supports rectangles, circles,
triangles, cubes, spheres, cylinders, and more.
Parameters:
shape — Shape name: "circle", "rectangle", "triangle", "cube",
"sphere", "cylinder", "cone", etc.
dims — JSON string of dimension values, e.g. '{"radius":5}'
or '{"length":10,"width":5,"height":3}'.
Inputs: shape (required), dims (required). Returns: result
Get current air quality data for any city.
Uses Open-Meteo Air Quality API (free, no key) after geocoding the city.
Returns European AQI, US AQI, PM2.5, PM10, and ozone levels.
Parameters:
city — City name to check air quality for (required), e.g. "London".
Inputs: city (required). Returns: result
Get real-time cryptocurrency prices from Binance.
Use this to check current crypto prices, 24-hour price changes, and
market data for major cryptocurrencies. Supports common names
(bitcoin, ethereum, solana) and direct ticker symbols.
Parameters:
symbol — Comma-separated cryptocurrency names or tickers
(default: "bitcoin,ethereum"). Examples: "bitcoin",
"ethereum,solana", "BTC,ETH,SOL".
Inputs: symbol. Returns: result
Get a 7-day weather forecast for any city.
Uses Open-Meteo (free, no key) after geocoding the city via Nominatim.
Returns daily high/low temps, precipitation, and weather codes.
Parameters:
city — City name to get forecast for (required), e.g. "London".
Inputs: city (required). Returns: result
Extract Open Graph metadata, title, description, and favicon from any URL.
Use this when an agent needs to preview a link — get the page title,
description, OG image, favicon, and content type. Ideal for link
previews, content summarization, and social media card extraction.
Parameters:
url — The full URL to scrape metadata from (e.g. "https://example.com/page").
Inputs: url (required). Returns: result
Get public holidays by country and year.
Use this to check bank holidays, plan around public holidays, or
calculate working days. Currently supports GB (UK), US (USA),
and IE (Ireland).
Parameters:
country — Two-letter country code (default: "GB").
Supported: "GB", "US", "IE".
year — Year to get holidays for (default: current year).
Example: 2026.
Inputs: country, year. Returns: result
Determine the astronomical season for a given date.
Use this to find which season a date falls in (Spring, Summer, Autumn,
Winter) for either the northern or southern hemisphere.
Parameters:
date — Date in ISO format (e.g. "2025-12-25"). Defaults to
today if empty.
hemisphere — "northern" (default) or "southern".
Inputs: date, hemisphere. Returns: result
Get current weather conditions for any city.
Uses Open-Meteo (free, no key) after geocoding the city via Nominatim.
Returns temperature, wind speed, weather code, and conditions.
Parameters:
city — City name to get weather for (required), e.g. "London".
Inputs: city (required). Returns: result
Get the ISO week number and year for a given date.
Use this to determine the week number of the year following ISO 8601
standards, useful for reporting and scheduling.
Parameters:
date — Date in ISO format (e.g. "2025-06-07"). Defaults to today
if empty.
Inputs: date. Returns: result
Detect if text appears to be gibberish or random strings.
Parameters:
text — Text to check for gibberish content.
Inputs: text (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Calculate gravitational force between two masses using Newton's law.
Parameters:
mass1 — Mass of first object in kg.
mass2 — Mass of second object in kg.
distance — Distance between centers in m.
Inputs: mass1 (required), mass2 (required), distance (required). Returns: result
Calculate Gunning Fog index for text readability.
Parameters:
text — Text to calculate Gunning Fog score for.
Inputs: text (required). Returns: result
Generate a cryptographic hash of input text.
Use this for password hashing, data integrity checks, digital signatures,
or any scenario requiring a one-way hash of a string.
Parameters:
text — The text to hash (required).
algorithm — Hashing algorithm: "md5", "sha1", "sha256", or "sha512"
(default: "sha256"). SHA-256 and SHA-512 are recommended for
security-sensitive use.
encoding — Output encoding: "hex" or "base64" (default: "hex").
Inputs: text (required), algorithm, encoding. Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Check the health and availability of all 11 API Hub endpoints.
Use this to verify that the MCP server and upstream API hub are reachable. Pings each endpoint and returns a status report indicating which endpoints are UP (2xx) and which are DOWN (error).
Returns a JSON summary with per-endpoint status and overall health.
Inputs: no named parameters. Returns: result
Calculate target heart rate zones for exercise.
Parameters:
age — Age in years.
resting_hr — Resting heart rate in bpm (default: 60).
Inputs: age (required), resting_hr. Returns: result
Display a hex dump of text with offset, hex bytes, and ASCII representation.
Parameters:
text — Text to create hex dump of.
Inputs: text (required). Returns: result
Convert hex color to CMYK (Cyan, Magenta, Yellow, Key/Black).
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Convert hex color to HSL (Hue, Saturation, Lightness) values.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Convert hex color to HSV (Hue, Saturation, Value) values.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Convert HSL values to RGB color.
Parameters:
hue — Hue angle (0-360).
saturation — Saturation percentage (0-100).
lightness — Lightness percentage (0-100).
Inputs: hue (required), saturation (required), lightness (required). Returns: result
Convert HSV values to hex color.
Parameters:
hue — Hue angle (0-360).
saturation — Saturation percentage (0-100).
value — Value/Brightness percentage (0-100).
Inputs: hue (required), saturation (required), value (required). Returns: result
Escape or unescape HTML entities in text.
Parameters:
text — Text with HTML to escape or unescape.
mode — 'escape' (default) or 'unescape'.
Inputs: text (required), mode. Returns: result
Make arbitrary HTTP requests from the API hub.
Use this when you need to call a URL but don't have direct
HTTP access. Supports GET, POST, PUT, DELETE, HEAD methods.
Parameters:
url — The full URL to request (required).
method — HTTP method: 'GET' (default), 'POST', 'PUT',
'DELETE', or 'HEAD'.
headers — Optional JSON string of extra headers:
'{"Authorization": "Bearer token"}'.
Inputs: url (required), method, headers. Returns: result
Fetch and analyze HTTP response headers from any URL.
Parameters:
url — URL to fetch headers from (e.g. 'https://example.com').
Inputs: url (required). Returns: result
Calculate ideal body weight using multiple formulas.
Parameters:
weight — Actual weight in kg.
height — Height in cm.
age — Age in years.
sex — 'male' (default) or 'female'.
method — 'devine' (default), 'robinson', 'miller', or 'hamwi'.
Inputs: weight (required), height (required), age (required), sex, +1 more. Returns: result
Indent each line of text by specified count of a character.
Parameters:
text — Text to indent.
count — Number of indent characters (default: 2).
char — Character to indent with (default: space).
Inputs: text (required), count, char. Returns: result
Calculate the inflation-adjusted value of money over time.
Parameters:
amount — Original amount of money.
from_year — Starting year (e.g. 2000).
to_year — Target year (e.g. 2026).
country — Country code for inflation data: 'US' (default), 'UK', 'DE', 'FR'.
Inputs: amount (required), from_year (required), to_year (required), country. Returns: result
Convert INI config format to JSON.
Parameters:
ini — INI content to convert.
Inputs: ini (required). Returns: result
Invert the case of each character (upper->lower, lower->upper).
Parameters:
text — Text to invert case of.
Inputs: text (required). Returns: result
Calculate investment growth with compound interest and optional monthly contributions.
Parameters:
principal — Initial investment amount.
rate — Expected annual return rate (e.g. 7.0 for 7%).
years — Investment time horizon in years.
contribution — Optional monthly contribution amount (default: 0).
Inputs: principal (required), rate (required), years (required), contribution. Returns: result
Calculate IPv4 subnet information: network, broadcast, hosts.
Parameters:
ip — IP address (e.g. '192.168.1.0').
cidr — CIDR prefix length (default: 24).
Inputs: ip (required), cidr. Returns: result
Expand abbreviated IPv6 addresses to full notation.
Parameters:
ipv6 — IPv6 address to expand (e.g. '::1' or '2001:db8::1').
Inputs: ipv6 (required). Returns: result
Query a JSON object using dot-notation path traversal.
Parameters:
json_str — JSON string to query.
path — Dot-notation path (e.g. 'users.0.name').
Inputs: json_str (required), path (required). Returns: result
Convert a JSON string to XML format.
Use this when you need XML output from JSON data for legacy systems,
SOAP APIs, or configuration files.
Parameters:
json_str — The JSON string to convert.
root — Name of the root XML element (default: "root").
Inputs: json_str (required), root. Returns: result
Convert JSON string to YAML format.
Parameters:
json_str — JSON string to convert.
Inputs: json_str (required). Returns: result
Get keyboard layout reference showing key positions and characters.
Parameters:
layout — Layout: 'us' (default), 'uk', 'de', 'fr', 'es', 'it'.
Inputs: layout. Returns: result
Analyze keyword density in text.
Parameters:
text — Text content to analyze.
keyword — Optional specific keyword to check density for.
Inputs: text (required), keyword. Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Calculate kinetic energy, mass, or velocity using KE = ½mv².
Parameters:
mass — Mass in kg (leave 0 if unknown).
velocity — Velocity in m/s (leave 0 if unknown).
energy — Kinetic energy in J (leave 0 if unknown).
Inputs: mass, velocity, energy. Returns: result
Detect the programming language of source code.
Parameters:
code — Source code to detect language of.
Inputs: code (required). Returns: result
Calculate lean body mass (LBM) using Boer formula.
Parameters:
weight — Weight in kg.
height — Height in cm.
age — Age in years.
sex — 'male' (default) or 'female'.
Inputs: weight (required), height (required), age (required), sex. Returns: result
Calculate the Levenshtein (edit) distance between two strings.
Use this to measure how many single-character edits (insert, delete,
substitute) are needed to change one string into another.
Parameters:
a — The first string.
b — The second string.
Inputs: a (required), b (required). Returns: result
Count total lines, non-empty lines, and blank lines in text.
Parameters:
text — Text to count lines in.
Inputs: text (required). Returns: result
Wrap long lines of code or text to a specified width.
Parameters:
text — Text or code to wrap lines in.
width — Maximum line width (default: 80).
break_long — Break words longer than width (default: True).
Inputs: text (required), width, break_long. Returns: result
Calculate Linsear Write readability formula score.
Parameters:
text — Text to calculate Linsear Write score for.
Inputs: text (required). Returns: result
Get a list of named CSS colors with hex values and RGB.
Parameters:
(no parameters needed)
Inputs: no named parameters. Returns: result
Get a list of all countries with ISO codes, calling codes, and continent.
Parameters:
(no parameters needed)
Inputs: no named parameters. Returns: result
Get a list of all currencies with ISO codes, symbols, and country usage.
Parameters:
(no parameters needed)
Inputs: no named parameters. Returns: result
Get a list of emojis by category. Leave empty for all.
Parameters:
category — Category: 'smileys', 'people', 'animals', 'food', 'travel', 'activities', 'objects', 'symbols', 'flags'.
Inputs: category. Returns: result
Get a list of all languages with ISO codes and native names.
Parameters:
(no parameters needed)
Inputs: no named parameters. Returns: result
Calculate loan payments, total interest, and full repayment schedule.
Parameters:
amount — Loan amount.
rate — Annual interest rate (e.g. 5.5 for 5.5%).
term_months — Loan term in months.
Inputs: amount (required), rate (required), term_months (required). Returns: result
Look up HTML entities by name, code, or character. Leave empty for full list.
Parameters:
entity — Search term.
Inputs: entity. Returns: result
Look up HTTP status code descriptions and categories.
Parameters:
code — HTTP status code (e.g. 404). Leave 0 for all codes.
Inputs: code. Returns: result
Look up MIME types by file extension. Leave empty for full list.
Parameters:
extension — File extension (e.g. 'pdf', 'jpg').
Inputs: extension. Returns: result
Calculate daily macronutrient targets (protein, carbs, fat).
Parameters:
weight — Weight in kg.
height — Height in cm.
age — Age in years.
sex — 'male' (default) or 'female'.
activity — Activity level (default: 'sedentary').
goal — 'maintain' (default), 'lose', or 'gain'.
Inputs: weight (required), height (required), age (required), sex, +2 more. Returns: result
Calculate profit margin percentage and markup from cost and revenue.
Parameters:
cost — Cost of goods sold.
revenue — Total revenue.
Inputs: cost (required), revenue (required). Returns: result
Calculate selling price from cost and markup percentage.
Parameters:
cost — Cost of goods sold.
markup_percent — Markup percentage (e.g. 50 for 50%).
Inputs: cost (required), markup_percent (required). Returns: result
Mask parts of sensitive text while keeping ends visible.
Parameters:
text — Text to mask (e.g. email, credit card, phone).
mask_char — Character for masking (default: '*').
visible_start — Characters to leave visible at start (default: 1).
visible_end — Characters to leave visible at end (default: 1).
Inputs: text (required), mask_char, visible_start, visible_end. Returns: result
Perform matrix operations: add, multiply, transpose, determinant.
Parameters:
operation — Operation: 'add', 'multiply', 'transpose', 'determinant'.
matrix_a — JSON array of arrays (e.g. '[[1,2],[3,4]]').
matrix_b — Second matrix for add/multiply (optional).
Inputs: operation (required), matrix_a (required), matrix_b. Returns: result
Merge two JSON objects with deep or shallow strategy.
Parameters:
json_a — First JSON string.
json_b — Second JSON string.
strategy — 'deep' (default) or 'shallow'.
Inputs: json_a (required), json_b (required), strategy. Returns: result
Compare BMR-based metabolic age to chronological age.
Parameters:
bmr — BMR in calories/day.
age — Chronological age in years.
sex — 'male' (default) or 'female'.
Inputs: bmr (required), age (required), sex. Returns: result
Calculate the midpoint between two points in 2D space.
Parameters:
x1 — X coordinate of first point.
y1 — Y coordinate of first point.
x2 — X coordinate of second point.
y2 — Y coordinate of second point.
Inputs: x1 (required), y1 (required), x2 (required), y2 (required). Returns: result
Minify CSS by removing whitespace and comments.
Parameters:
css — CSS content to minify.
Inputs: css (required). Returns: result
Minify HTML by removing whitespace and comments.
Parameters:
html — HTML content to minify.
Inputs: html (required). Returns: result
Calculate momentum, mass, or velocity using p = mv.
Parameters:
mass — Mass in kg (leave 0 if unknown).
velocity — Velocity in m/s (leave 0 if unknown).
momentum — Momentum in kg·m/s (leave 0 if unknown).
Inputs: mass, velocity, momentum. Returns: result
Convert text to or from Morse code.
Use this to encode text into dots-and-dashes Morse code, or decode
Morse code back into readable text.
Parameters:
text — The text or Morse code string to convert.
mode — "encode" (text → Morse, default) or "decode" (Morse → text).
Inputs: text (required), mode. Returns: result
Calculate monthly mortgage payments, total interest, and amortization.
Parameters:
principal — Loan principal amount.
rate — Annual interest rate (e.g. 5.5 for 5.5%).
years — Loan term in years.
Inputs: principal (required), rate (required), years (required). Returns: result
Convert identifier names between naming conventions.
Parameters:
name — Identifier name to convert.
target — Target convention: 'snake_case' (default), 'camelCase',
'PascalCase', 'kebab-case', 'UPPER_CASE'.
Inputs: name (required), target. Returns: result
Convert text to the NATO phonetic alphabet representation.
Use this to spell out words using standard NATO code words
(Alpha, Bravo, Charlie, etc.), useful for clear radio/phone communication.
Parameters:
text — The text to convert to NATO phonetic words.
Inputs: text (required). Returns: result
Normalize Unicode text to NFC, NFD, NFKC, or NFKD form.
Parameters:
text — Text to normalize.
form — Normalization form: 'nfc' (default), 'nfd', 'nfkc', or 'nfkd'.
Inputs: text (required), form. Returns: result
Convert numbers to English words (e.g. 1234 -> 'one thousand two hundred thirty four').
Parameters:
number — Number to convert to words.
currency — Optional currency code for money format.
Inputs: number (required), currency. Returns: result
Calculate ovulation window and fertile days.
Parameters:
last_period — First day of last menstrual period (ISO date).
cycle_days — Average cycle length in days (default: 28).
Inputs: last_period, cycle_days. Returns: result
Calculate running/walking pace, speed, and finish time.
Parameters:
distance — Distance covered.
time_hours — Hours (default: 0).
time_minutes — Minutes (default: 0).
time_seconds — Seconds (default: 0).
unit — 'km' (default) or 'miles'.
Inputs: distance (required), time_hours, time_minutes, time_seconds, +1 more. Returns: result
Pad text to specified length with a character on left, right, or both sides.
Parameters:
text — Text to pad.
length — Target total length.
char — Padding character (default: space).
side — 'left' (default), 'right', or 'both'.
Inputs: text (required), length (required), char, side. Returns: result
Check if text is a palindrome (reads same forwards and backwards).
Parameters:
text — Text to check for palindrome property.
Inputs: text (required). Returns: result
Check if text is a pangram (contains every letter of alphabet).
Parameters:
text — Text to check for pangram property.
Inputs: text (required). Returns: result
Look up standard paper sizes (ISO A, B, C series, US sizes).
Use this to find dimensions in mm and inches for any paper size.
Returns all sizes if no specific size is given.
Parameters:
size — Paper size name like "A4", "Letter", "Legal", "B5", "C4".
Empty string returns all standard sizes.
Inputs: size. Returns: result
Count paragraphs and analyze paragraph structure.
Parameters:
text — Text to count paragraphs in.
Inputs: text (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Parse and validate international phone numbers.
Use this to extract country code, national number, and
validate formatting. Supports major country codes.
Parameters:
phone — Phone number string (e.g. '+441234567890').
Inputs: phone (required). Returns: result
Parse RSS or Atom XML feeds into clean JSON with entries.
Use this to monitor news feeds, blog updates, or any RSS/Atom source.
Returns feed metadata (title, URL) and up to 20 latest entries with
title, link, description, and publication date.
Parameters:
url — The full URL of the RSS or Atom feed to parse
(e.g. "https://example.com/feed.xml").
Inputs: url (required). Returns: result
Detect passive voice usage in text and suggest active alternatives.
Parameters:
text — Text to analyze for passive voice.
Inputs: text (required). Returns: result
Calculate percentages: find what % X is of Y, or what is X% of Y.
Parameters:
operation — 'of' (what is X% of Y) or 'what' (what % is X of Y).
value — The value to calculate.
total — Total/whole value (required for 'what' operation).
percent — Percentage (required for 'of' operation).
Inputs: operation (required), value (required), total, percent. Returns: result
Calculate the percentage change between two values.
Parameters:
old_value — Original value.
new_value — New value.
Inputs: old_value (required), new_value (required). Returns: result
Convert between px, pt, rem, em, and percent CSS units.
Parameters:
value — Value to convert.
from_unit — Source unit: 'px', 'pt', 'rem', 'em', 'percent'.
to_unit — Target unit.
base_size — Base font size (default: 16px).
Inputs: value (required), from_unit (required), to_unit (required), base_size. Returns: result
Check if a network port is open on a host.
Parameters:
host — Hostname or IP address.
port — Port number (1-65535).
protocol — 'tcp' (default) or 'udp'.
Inputs: host (required), port (required), protocol. Returns: result
Calculate pressure, force, or area using P = F/A.
Parameters:
force — Force in N (leave 0 if unknown).
area — Area in m² (leave 0 if unknown).
pressure — Pressure in Pa (leave 0 if unknown).
Inputs: force, area, pressure. Returns: result
Convert between pressure units: psi, bar, kPa, atm, mmHg, Pa.
Parameters:
value — Pressure value to convert.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Check if a number is prime, find next prime, or factorize into primes.
Parameters:
operation — 'check' (default), 'next', or 'factors'.
value — Number to operate on.
Inputs: value (required), operation. Returns: result
Prettify, validate, or minify a JSON string.
Use this for debugging, formatting API responses, cleaning up configuration
files, or verifying that a string is valid JSON.
Parameters:
json_string — The JSON string to process (required). Pass the raw JSON text.
mode — Operation: "prettify" (indent + sort keys), "validate"
(check syntax only), or "minify" (compact, no whitespace)
(default: "prettify").
Inputs: json_string (required), mode. Returns: result
Proofread text for grammar, spelling, punctuation, and style issues.
Parameters:
text — Text to proofread.
Inputs: text (required). Returns: result
Solve proportion: find missing term in a:b = c:d.
Parameters:
a — First term.
b — Second term.
c — Third term.
d — Fourth term (leave 0 if solving for d).
solve — Which term to solve for: 'a', 'b', 'c', or 'd' (default: 'd').
Inputs: a (required), b (required), c (required), d, +1 more. Returns: result
Generate structured pros and cons analysis from text or topic.
Parameters:
text — Topic, product, or decision to analyze.
Inputs: text (required). Returns: result
Count punctuation marks by type in text.
Parameters:
text — Text to count punctuation in.
Inputs: text (required). Returns: result
Solve Pythagorean theorem: find missing side of right triangle.
Parameters:
a — Side a (leave 0 if unknown).
b — Side b (leave 0 if unknown).
c — Hypotenuse c (leave 0 if unknown).
Inputs: a, b, c. Returns: result
Solve quadratic equation ax² + bx + c = 0.
Parameters:
a — Coefficient of x².
b — Coefficient of x.
c — Constant term.
Inputs: a (required), b (required), c (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Generate a random hex color, optionally from specific color families.
Parameters:
style — 'bright' (default), 'pastel', 'dark', 'muted', or 'any'.
Inputs: style. Returns: result
Solve ratio proportions: find missing value in a:b = c:d.
Parameters:
a — First value of first ratio.
b — Second value of first ratio.
value — Known value to solve for.
side — Which side the value represents: 'a' or 'b' (default: 'a').
Inputs: a (required), b (required), value, side. Returns: result
Analyze readability distribution across sentences/paragraphs.
Parameters:
text — Text to analyze readability distribution for.
Inputs: text (required). Returns: result
Analyze URL readability scores (Flesch-Kincaid, Gunning Fog, etc).
Parameters:
url — The URL to analyze for readability.
Inputs: url (required). Returns: result
Estimate reading time for text at a given words-per-minute rate.
Parameters:
text — Text to estimate reading time for.
wpm — Reading speed in words per minute (default: 200).
Inputs: text (required), wpm. Returns: result
Read and extract clean text content from any URL. Returns article text, title, and metadata.
Parameters:
url — URL to read content from.
Inputs: url (required). Returns: result
Escape special regex characters in a string for literal matching.
Parameters:
text — String to escape for regex use.
Inputs: text (required). Returns: result
Remove diacritical marks/accents from characters.
Parameters:
text — Text with accents to remove.
Inputs: text (required). Returns: result
Remove common stop words from text for cleaner analysis.
Parameters:
text — Text to remove stopwords from.
language — Language of stopwords (default: 'english').
Inputs: text (required), language. Returns: result
Compare the financial impact of renting vs buying a home.
Parameters:
monthly_rent — Monthly rent amount.
home_price — Home purchase price.
down_payment — Down payment amount.
rate — Mortgage interest rate.
years — Time horizon in years (default: 5).
Inputs: monthly_rent (required), home_price (required), down_payment (required), rate (required), +1 more. Returns: result
Find repeated or duplicated words in text.
Parameters:
text — Text to find repeated words in.
Inputs: text (required). Returns: result
Research any topic and return a structured report with key findings and recommendations.
Use this when you need a quick research briefing on any subject.
Returns title, overview, key findings, and recommendations.
Saves tokens compared to doing the research yourself.
Parameters:
query — The topic or question to research (e.g. "best ergonomic office chairs 2026").
Inputs: query (required). Returns: result
Calculate retirement savings growth and projected nest egg.
Parameters:
current_age — Current age in years.
retirement_age — Target retirement age.
savings — Current retirement savings.
monthly_contribution — Monthly contribution (default: 0).
rate — Expected annual return (default: 7.0).
Inputs: current_age (required), retirement_age (required), savings (required), monthly_contribution, +1 more. Returns: result
Perform reverse DNS lookup (IP to hostname).
Parameters:
ip_address — IP address to look up (e.g. '8.8.8.8').
Inputs: ip_address (required). Returns: result
Reverse geocode coordinates to a human-readable address.
Uses Nominatim (free, no key). Returns display name, structured address
components (road, city, country, postcode), and OSM identifiers.
Parameters:
lat — Latitude coordinate (required), e.g. 51.5.
lon — Longitude coordinate (required), e.g. -0.12.
Inputs: lat (required), lon (required). Returns: result
Reverse the characters in a string.
Parameters:
text — Text to reverse.
Inputs: text (required). Returns: result
Rewrite content with AI — change tone, length, audience, or format.
Use this to repurpose content for different channels. Takes any text
and rewrites it according to your specifications. Powered by DeepSeek
V4 Flash. Great for SEO content creation, social media adaptation,
or making technical content accessible.
Parameters:
text — The text content to rewrite (required).
tone — Desired tone: "professional", "casual", "persuasive",
"formal", "friendly", or "humorous". Default: "professional".
length — Target word count (default: 300).
audience — Target audience (default: "general").
format — Output format: "paragraph", "bullet_points",
or "single_sentence". Default: "paragraph".
Inputs: text (required), tone, length, audience, +1 more. Returns: result
Convert RGB color values to HSL (Hue, Saturation, Lightness).
Parameters:
red — Red value (0-255).
green — Green value (0-255).
blue — Blue value (0-255).
Inputs: red (required), green (required), blue (required). Returns: result
Calculate Return on Investment (ROI) percentage.
Parameters:
gain — Total gain from investment.
cost — Total cost of investment.
Inputs: gain (required), cost (required). Returns: result
Roll one or more dice with specified number of sides.
Parameters:
sides — Number of sides per die (default: 6).
count — Number of dice to roll (default: 1).
Inputs: sides, count. Returns: result
Convert between Roman numerals and Arabic numbers.
Parameters:
value — Value to convert.
mode — 'to-roman' (number->Roman, default) or 'from-roman'.
Inputs: value (required), mode. Returns: result
Apply ROT13 or custom ROT-N cipher (letter rotation).
Parameters:
text — Text to transform.
shift — Rotation amount (default: 13).
Inputs: text (required), shift. Returns: result
Calculate salary breakdown: hourly, daily, weekly, monthly, annual equivalents.
Parameters:
salary — Salary amount.
frequency — 'annual', 'monthly', 'weekly', 'daily', or 'hourly'.
currency — Currency code (default: 'USD').
Inputs: salary (required), frequency, currency. Returns: result
Convert salary between currencies with purchasing power comparison.
Parameters:
salary — Salary amount.
from_currency — Source currency code (default: 'USD').
to_currency — Target currency code (default: 'EUR').
hours_per_week — Hours worked per week (default: 40).
weeks_per_year — Weeks worked per year (default: 52).
Inputs: salary (required), from_currency, to_currency, hours_per_week, +1 more. Returns: result
Calculate monthly savings needed to reach a financial goal.
Parameters:
target — Target savings amount.
rate — Annual interest rate (e.g. 3.0 for 3%).
years — Number of years to save.
initial — Initial savings amount (default: 0).
Inputs: target (required), rate (required), years (required), initial. Returns: result
Convert a number to and from scientific notation.
Parameters:
value — Number to convert to scientific notation.
precision — Decimal places in mantissa (default: 4).
Inputs: value (required), precision. Returns: result
Scrape meta tags (title, description, OG, Twitter cards, etc) from any URL.
Parameters:
url — URL to scrape meta tags from.
Inputs: url (required). Returns: result
Search the web using multiple engines (Wikipedia, DuckDuckGo, Bing, Brave).
Parameters:
query — Search query.
engine — Engine: 'auto' (default), 'wikipedia', 'duckduckgo', 'bing', 'brave'.
count — Number of results (default: 5).
Inputs: query (required), engine, count. Returns: result
Analyze sentence length distribution and variability.
Parameters:
text — Text to analyze sentence lengths.
Inputs: text (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Randomly shuffle characters in a string.
Parameters:
text — Text to shuffle.
Inputs: text (required). Returns: result
Round a number to a specified number of significant figures.
Parameters:
value — Number to round.
sig_figs — Number of significant figures (default: 3).
Inputs: value (required), sig_figs. Returns: result
Calculate simple interest: interest = principal × rate × time.
Parameters:
principal — Principal amount.
rate — Annual interest rate (e.g. 5.0 for 5%).
time — Time period in years.
Inputs: principal (required), rate (required), time (required). Returns: result
Simplify complex text into plain, easy-to-understand language.
Parameters:
text — Text to simplify.
Inputs: text (required). Returns: result
Calculate Systematic Investment Plan (SIP) returns with compounding.
Parameters:
monthly_investment — Monthly investment amount.
rate — Expected annual return rate (e.g. 12.0 for 12%).
years — Investment period in years.
Inputs: monthly_investment (required), rate (required), years (required). Returns: result
Calculate optimal sleep schedule based on sleep cycles (90 min each).
Parameters:
bedtime — Target bedtime (HH:MM, 24h). Defaults to calculating from wake time.
wake_time — Target wake time (HH:MM, 24h). Defaults to calculating from bedtime.
cycles — Number of sleep cycles (default: 5, range: 4-6).
Inputs: bedtime, wake_time, cycles. Returns: result
Calculate the slope, intercept, and equation of a line between two points.
Parameters:
x1 — X coordinate of first point.
y1 — Y coordinate of first point.
x2 — X coordinate of second point.
y2 — Y coordinate of second point.
Inputs: x1 (required), y1 (required), x2 (required), y2 (required). Returns: result
Convert text to URL-friendly slug.
Parameters:
text — Text to slugify.
Inputs: text (required). Returns: result
Calculate SMOG (Simple Measure of Gobbledygook) readability grade.
Parameters:
text — Text to calculate SMOG index for.
Inputs: text (required). Returns: result
Sort an array of values or objects.
Parameters:
data — JSON array to sort.
key — Sort key for objects. Empty for value arrays.
order — 'asc' (default) or 'desc'.
Inputs: data (required), key, order. Returns: result
Generate the Soundex phonetic code for a word.
Use this for name matching and phonetic indexing. Soundex encodes
words by their pronunciation, useful for finding similar-sounding names.
Parameters:
text — The word to encode with Soundex.
Inputs: text (required). Returns: result
Estimate speaking time for text at a given words-per-minute rate.
Parameters:
text — Text to estimate speaking time for.
wpm — Speaking speed in words per minute (default: 150).
Inputs: text (required), wpm. Returns: result
Convert between speed units: km/h, mph, m/s, knots, ft/s.
Parameters:
value — Speed value to convert.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Format/beautify SQL queries with configurable dialect.
Parameters:
sql — Raw SQL query to format.
dialect — SQL dialect: 'ansi' (default), 'mysql', 'postgresql', 'sqlite'.
Inputs: sql (required), dialect. Returns: result
Calculate total stock return including price change and dividends.
Parameters:
initial_price — Purchase price per share.
final_price — Current/sale price per share.
dividends — Total dividends received per share (default: 0).
Inputs: initial_price (required), final_price (required), dividends. Returns: result
Escape or unescape special characters in strings.
Parameters:
text — String to escape or unescape.
mode — 'escape' (default) or 'unescape'.
Inputs: text (required), mode. Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Swap upper and lower case characters in text.
Parameters:
text — Text to swap case of.
Inputs: text (required). Returns: result
Calculate tax bracket, effective rate, and take-home pay.
Parameters:
income — Annual taxable income.
year — Tax year (default: 2026).
country — Country code: 'US' (default), 'UK'.
filing — Filing status: 'single' (default), 'married', 'head'.
Inputs: income (required), year, country, filing. Returns: result
Calculate Total Daily Energy Expenditure (TDEE) based on activity level.
Parameters:
weight — Weight in kg.
height — Height in cm.
age — Age in years.
sex — 'male' (default) or 'female'.
activity — 'sedentary', 'light', 'moderate', 'active', or 'very_active'.
Inputs: weight (required), height (required), age (required), sex, +1 more. Returns: result
Convert a temperature from any unit to all other units (C, F, K, R).
Parameters:
value — Temperature value.
from_unit — Source unit: 'c', 'f', 'k', 'r'.
Inputs: value (required), from_unit (required). Returns: result
Test a regular expression against text and return all matches.
Use this to debug regex patterns, extract matching groups,
or verify patterns before using in your code.
Parameters:
regex — Regular expression pattern (e.g. '\d+').
text — Text to test the regex against.
flags — Regex flags (default: 'g').
Inputs: regex (required), text (required), flags. Returns: result
Analyze overall text complexity using multiple readability dimensions.
Parameters:
text — Text to analyze complexity of.
Inputs: text (required). Returns: result
Compare two texts and return line-by-line differences.
Use this to find what changed between document versions.
Returns each differing line with the old and new value.
Parameters:
text_a — First text (the 'before' version).
text_b — Second text (the 'after' version).
Inputs: text_a (required), text_b (required). Returns: result
Get comprehensive text statistics including all counts and metrics.
Parameters:
text — Text to analyze with full statistics.
Inputs: text (required). Returns: result
Convert between time units: seconds, minutes, hours, days, weeks, months, years.
Parameters:
value — Time value to convert.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Calculate tip amount and split bill between multiple people.
Parameters:
bill — Total bill amount.
percent — Tip percentage (default: 15).
split — Number of people to split with (default: 1).
Inputs: bill (required), percent, split. Returns: result
Convert text to title case (capitalize major words).
Parameters:
text — Text to convert to title case.
Inputs: text (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Find TODO, FIXME, HACK, NOTE, XXX comments in source code.
Parameters:
code — Source code to scan for TODO/fixme comments.
Inputs: code (required). Returns: result
Convert TOML format to JSON.
Use this to transform TOML configuration files (e.g. pyproject.toml)
into JSON for programmatic access.
Parameters:
toml — TOML-formatted string to convert.
Inputs: toml (required). Returns: result
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result
Truncate text to specified length with optional ellipsis.
Parameters:
text — Text to truncate.
length — Maximum length (default: 100).
ellipsis — Append '...' (default: true).
Inputs: text (required), length, ellipsis. Returns: result
Convert tab-separated values (TSV) to JSON format.
Use this to transform TSV data from spreadsheets or database exports
into structured JSON arrays.
Parameters:
tsv — TSV text with header row and data rows (tab-separated).
Inputs: tsv (required). Returns: result
Reconstruct nested JSON from dot-notation flattened format.
Parameters:
json_str — Flattened JSON string.
separator — Separator (default: '.').
Inputs: json_str (required), separator. Returns: result
Count and list unique words with their frequencies.
Parameters:
text — Text to extract unique words from.
Inputs: text (required). Returns: result
Encode or decode URL/URI strings.
Use this to safely encode special characters for URLs or
decode percent-encoded URL strings back to readable text.
Parameters:
text — The string to encode or decode.
mode — 'encode' (default) or 'decode'.
Inputs: text (required), mode. Returns: result
Parse a URL into its components: protocol, host, path, query, fragment.
Parameters:
url — URL string to parse (e.g. 'https://example.com/page?q=1#section').
Inputs: url (required). Returns: result
Validate IBAN format and check digit for international bank accounts.
Parameters:
iban — IBAN number to validate.
Inputs: iban (required). Returns: result
Validate JSON string syntax and optionally against a JSON Schema.
Parameters:
json_str — JSON string to validate.
schema — Optional JSON Schema to validate against.
Inputs: json_str (required), schema. Returns: result
Validate a VAT number format for EU countries.
Parameters:
vat — VAT number to validate.
Inputs: vat (required). Returns: result
Calculate VAT (Value Added Tax) amounts and totals.
Parameters:
amount — Price amount.
rate — VAT rate percentage (default: 20.0).
inclusive — True if amount includes VAT (default: True), False if exclusive.
Inputs: amount (required), rate, inclusive. Returns: result
Verify whether an email address is valid and deliverable.
Use this to validate user-provided email addresses during sign-up, form
submission, or contact list cleaning. Checks syntax, domain validity,
and whether the address is from a disposable email provider.
Parameters:
email — The email address to verify (required).
Inputs: email (required). Returns: result
Encrypt or decrypt text using the Vigenère cipher with a keyword.
Use this for classical encryption using the Vigenère method, which
shifts letters by the repeating key.
Parameters:
text — The plaintext or ciphertext string.
key — The keyword used for encryption/decryption.
mode — "encrypt" (default) or "decrypt".
Inputs: text (required), key (required), mode. Returns: result
Estimate VO₂ max using resting heart rate or exercise test.
Parameters:
resting_hr — Resting heart rate in bpm.
age — Age in years.
sex — 'male' (default) or 'female'.
weight — Body weight in kg (optional, for exercise method).
method — 'resting' (default) or 'exercise'.
Inputs: resting_hr (required), age (required), sex, weight, +1 more. Returns: result
Convert between volume units: liters, gallons, quarts, cups, ml, oz, cubic meters.
Parameters:
value — Volume value to convert.
from_unit — Source unit.
to_unit — Target unit.
Inputs: value (required), from_unit (required), to_unit (required). Returns: result
Calculate waist-to-hip ratio and health risk assessment.
Parameters:
waist — Waist circumference in cm.
hip — Hip circumference in cm.
sex — 'male' (default) or 'female'.
Inputs: waist (required), hip (required), sex. Returns: result
Check your wallet credit balance.
Use this to see how many credits you have remaining.
Credits are used to power AI tools (chat, rewrite, analyze).
Buy more via wallet_buy.
Parameters:
api_key — Your API key (starts with 'gh_'). Create one at api.gadgethumans.com.
Inputs: api_key (required). Returns: result
Get a link to buy credits for your wallet.
Use this to purchase credits that power AI tools.
$10 = 1000 credits. Each AI call costs ~1 credit.
After purchasing, use your API key with the AI tools.
Inputs: no named parameters. Returns: result
Create a new wallet and get an API key.
Use this to get started with the GadgetHumans credit system.
Your API key starts with 'gh_' and is used to authenticate AI tool calls.
Parameters:
email — Optional email address for payment receipts.
Inputs: email. Returns: result
Calculate recommended daily water intake.
Parameters:
weight — Body weight in kg.
activity_minutes — Daily exercise minutes (default: 0).
temperature — Climate: 'moderate' (default), 'hot', or 'cold'.
Inputs: weight (required), activity_minutes, temperature. Returns: result
Find the nearest web-safe color for a given hex color.
Parameters:
hex_color — Hex color without # (e.g. '3498db').
Inputs: hex_color (required). Returns: result
Scrape a URL and return clean markdown text. PAID-ONLY: requires a valid x-api-key.
Fetches the URL content, strips HTML tags (scripts, styles, nav, etc.),
converts headings and paragraphs to markdown format, and returns the clean text.
Has a 5-second timeout. Only works with a valid API key (paid tier).
Parameters:
url — The full URL to scrape (e.g. 'https://example.com/page').
Inputs: url (required). Returns: result
Analyze whitespace usage: spaces, tabs, newlines, trailing spaces.
Parameters:
text — Text to analyze whitespace in.
Inputs: text (required). Returns: result
Count words, characters, sentences, paragraphs, and average word length.
Parameters:
text — Text to count words in.
Inputs: text (required). Returns: result
Analyze word frequency distribution in text, sorted by count.
Parameters:
text — Text to analyze word frequency in.
Inputs: text (required). Returns: result
Analyze word length distribution with histogram data.
Parameters:
text — Text to analyze word length distribution.
Inputs: text (required). Returns: result
Calculate string similarity between two words or phrases.
Use this to compare strings using various algorithms — Jaccard index,
cosine similarity, or Sørensen-Dice coefficient.
Parameters:
a — The first string to compare.
b — The second string to compare.
method — Similarity method: "jaccard" (default), "cosine", or "dice".
Inputs: a (required), b (required), method. Returns: result
Calculate work, force, or distance using W = Fd.
Parameters:
force — Force in N (leave 0 if unknown).
distance — Distance in m (leave 0 if unknown).
work — Work in J (leave 0 if unknown).
Inputs: force, distance, work. Returns: result
Wrap text to specified line width.
Parameters:
text — Text to wrap.
width — Maximum line width (default: 80).
Inputs: text (required), width. Returns: result
Convert XML text to structured JSON format.
Parameters:
xml — XML content to convert.
Inputs: xml (required). Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 338 tools
With 338 tools, massive overlap is pervasive: there are a dozen readability metric tools (gunning_fog_score, smog_index, ari_score, etc.), multiple unique-ID generators (generate_uuid, generate_nanoid, generate_ulids), and duplicate text transformers (invert_case vs swap_case, summarize vs tldr). Agents would constantly struggle to pick between near-identical tools.
Naming is highly inconsistent: some tools use verb_noun (generate_qr_code, convert_currency), others use *_calc or calculate_* (mortgage_calculator, calculate_date), and a large block uses single vague words (summarize, translate, grammar, faq, quiz). The mixed convert_* and *_convert patterns (convert_units vs speed_convert) further break predictability.
338 tools is an extreme count, far beyond the 50+ threshold for a score of 1. Most are trivial one-function utilities like flip_coin, roll_dice, reverse_text, and pad_text, which bloat the tool surface and make selection dramatically harder without adding meaningful capability.
The server has no coherent domain—it is a grab-bag of physics, finance, text, color, code, and web utilities—so completeness is ill-defined and impossible to satisfy. Despite enormous breadth, coverage is fragmented (many near-duplicate readability/color/loan tools) while whole categories like image processing or PDF handling are absent.
380+ live data, validation and utility APIs in one MCP server: IP, DNS, email, FX, weather and more.
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
The OpenRouter for tools. One MCP connection gives any AI agent 254 hosted tools, pay per call.
Discover and call 10,000+ production APIs from one MCP server. Pay-per-call billing for AI agents.
socialD
{d}
Inputs: text (required), to, tool, desc, +1 more. Returns: result