Every AI agent spends a surprising amount of time on boring, deterministic chores: generating a UUID for a job ID, hashing a file to verify integrity, base64-encoding a payload, converting a timestamp between timezones, or diffing two versions of a document. These tasks are perfect for a tiny HTTP call — and terrible for a language model to re-implement from scratch, because they are the exact places where a model will confidently produce subtly wrong output.
Agent Media Tools has a cluster of free developer-utility endpoints that are quietly the most reused tools in my own agent workflows. No API key required, no SDK to install, JSON in, JSON out. This post walks through the ones I reach for daily, with real curl and Python requests examples you can paste into a shell today.
You can absolutely generate a UUID with crypto.randomUUID() or hash with openssl. But agents don't always have those available: they might be running in a sandboxed notebook, on a remote worker without a shell, or inside an MCP client that can only call tools. A hosted endpoint gives you one consistent interface across every environment, plus a few things local code usually lacks:
curl and skip key management entirely for one-off scripts.hash_text, base64_encode, generate_uuid, and friends), so Claude, Codex, or your own agent can call them without writing any REST code.Name any durable artifact — a job, a delivery, a webhook event — and it needs an ID. The /api/uuid endpoint returns v4 or v7 UUIDs, up to 50 per call.
curl "https://agentmediatools.com/api/uuid?version=v7&count=3"
{
"success": true,
"count": 3,
"uuids": ["0196f2c9-7a3b-7000-8000-000000000001", "...", "..."],
"version": "v7"
}
v7 UUIDs embed a millisecond timestamp, which makes them roughly sortable — nice for job queues and logs. In Python:
import requests
r = requests.get("https://agentmediatools.com/api/uuid", params={"version": "v7", "count": 5})
job_ids = r.json()["uuids"]
The /api/password endpoint generates random passwords and — more usefully — tells you their entropy in bits and a strength rating. That's the kind of quantified output an agent can actually reason about when provisioning a test account or a database user.
curl "https://agentmediatools.com/api/password?length=24"
{
"success": true,
"password": "dK9!x@2L#mQ7$wR5%tY8&zC4",
"length": 24,
"entropy_bits": 141,
"strength": "strong"
}
Control the character set with symbols, numbers, and uppercase flags (default all on). The generator uses crypto.randomInt, so it's not just Math.random dressed up — good enough for throwaway credentials and quite good for anything below a real secrets manager.
Verifying that a downloaded file or a webhook payload wasn't corrupted is a classic agent task. /api/hash supports md5, sha1, sha256, sha384, and sha512.
curl "https://agentmediatools.com/api/hash?text=hello%20world&algo=sha256"
{
"success": true,
"input": "hello world",
"algorithm": "sha256",
"hash": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
"length": 64
}
I use this in a watchdog-style flow: hash a page or artifact, store the digest, and compare on the next run to detect changes — the same idea as the Website Watchdog API, but for arbitrary bytes I control myself.
When an agent needs to stuff binary data into JSON — a small image, a PDF chunk, an API payload — base64 is the universal envelope. /api/base64 does both directions with one action parameter.
curl "https://agentmediatools.com/api/base64?action=encode&text=agent%20tools"
# {"success":true,"action":"encode","input":"agent tools","output":"YWdlbnQgdG9vbHM="}
curl "https://agentmediatools.com/api/base64?action=decode&text=YWdlbnQgdG9vbHM="
# {"success":true,"action":"decode","input":"YWdlbnQgdG9vbHM=","output":"agent tools"}
Unix timestamps, ISO strings, and timezone conversions are a constant source of off-by-one bugs in agent code. /api/timestamp converts between Unix seconds and human-readable forms, and supports the now shortcut:
curl "https://agentmediatools.com/api/timestamp?value=now"
{
"success": true,
"unix": 1784931600,
"iso": "2026-08-24T12:00:00.000Z",
"utc": "Mon, 24 Aug 2026 12:00:00 GMT",
"local": "Mon Aug 24 2026 08:00:00 GMT-0400 (Eastern Daylight Time)"
}
Pass a Unix-seconds value to convert it. For named timezones, /api/timezone/convert?time=2026-08-24T18:00:00Z&from=America/New_York&to=Asia/Tokyo renders the same explicit instant in both zones, and /api/timezone/now?tz=... gives the current time anywhere. Avoid offset-free date strings here: the endpoint formats an instant; it does not assign a timezone to an ambiguous wall-clock value.
Two endpoints I assumed I'd never use, then used constantly:
/api/units — length, weight, temperature, volume, and speed. curl "https://agentmediatools.com/api/units?value=5&from=mi&to=km&category=length" returns {"success":true,"value":5,"from":"mi","to":"km","result":8.0467,...}./api/color/convert?value=%23c9a84c — parse hex, rgb, or hsl and get hex, rgba, hsla, cmyk, luminance, and an is_light flag. That flag is gold for agents that generate UI or images and need to pick readable text colors automatically.Spreadsheet-shaped data shows up everywhere in agent work, and /api/csv-convert handles both directions with proper quote handling:
curl -X POST "https://agentmediatools.com/api/csv-convert" \
-H "Content-Type: application/json" \
-d '{"input":"[{\"name\":\"iris\",\"tier\":\"pro\"},{\"name\":\"marcus\",\"tier\":\"free\"}]","direction":"json2csv"}'
{
"success": true,
"result": "name,tier\niris,pro\nmarcus,free",
"headers": ["name", "tier"],
"rows": 2,
"format": "csv"
}
For text analysis, /api/text/stats returns character/word/sentence/paragraph counts, a reading-time estimate, top word frequencies, and an approximate Flesch-Kincaid readability score — useful when an agent needs to summarize a document to a target reading level. And /api/token-count estimates tokens per model (gpt-4o, claude-3-5-sonnet, llama-3, mistral) plus per-call cost estimates, which is my go-to sanity check before feeding a big context to an expensive model. It's honest about being approximate — the response notes ±5-10% versus a real tokenizer.
The remaining utilities are small but surprisingly sticky:
/api/diff?text1=...&text2=... — line-level diff with counts of additions, deletions, and common lines. Perfect for "what changed between these two configs?" checks./api/jwt-decode (POST {"token": "..."}) — decode header and payload without verifying signature; handy when debugging an OAuth flow inside an agent./api/slugify, /api/case-convert, /api/url-parse, /api/mime, /api/json-format, /api/regex/test — slug generation, case conversion, URL decomposition, MIME lookups, JSON pretty-print/validate/minify, and regex testing.If you run agents through an MCP client, you don't need REST at all. The same deterministic logic is exposed as MCP tools: generate_uuid, generate_password, base64_encode, base64_decode, decode_jwt, hash_text, csv_convert, timestamp_convert, unit_convert, and text_diff. One line in your MCP config and your agent can generate an ID, hash a payload, and diff two documents without ever assembling a URL.
These endpoints are intentionally small and stateless at the tool level, subject to the platform's normal free-tool limits. They are not a substitute for a secrets manager, and token counts, entropy ratings, and readability scores are estimates by design. CSV conversion does not support embedded multiline fields, Base64 decoding is permissive rather than a strict validator, and the color conversion response currently leaves name as null.
Next time your agent is about to hand-roll a UUID loop or guess what time it is in Tokyo, point it at a utility endpoint instead. They're free, keyless, and consistent across curl, Python, and MCP — the three ways agents actually talk to the world. Start with /api/uuid and /api/hash, and you'll be surprised how fast the rest of the cluster earns a place in your prompts.
Run the same tools in the browser, or call them from your agent with an API key.
Open toolbox