# Pay-per-call APIs for AI agents: 33 tools, no API key, from $0.002 (x402 on Base)
Canonical: https://grokzilla.shop | Last updated: 2026-10-14
A pay-per-call API is an HTTP API you pay for one request at a time instead of with an account, API key or subscription. On this site an AI agent sends a normal POST, gets HTTP 402 with the price, pays in USDC on Base with x402 v2, and retries the same request to get the JSON result.
## How payment works
1. POST the JSON body to the skill endpoint with no payment header.
2. The server answers HTTP 402 with a PAYMENT-REQUIRED header (x402 v2, scheme exact, network eip155:8453, asset USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69).
3. Sign the exact USDC amount with any x402 v2 client and retry with the PAYMENT-SIGNATURE header.
## Skills and prices
| id | endpoint | price (USD per call) | docs |
|---|---|---|---|
| osint_graph | POST /api/skills/osint-graph | $0.01 | https://grokzilla.shop/docs/osint-graph |
| seo | POST /api/skills/seo | $0.012 | https://grokzilla.shop/docs/seo |
| seo_v2 | POST /api/skills/seo-v2 | $0.0997 | https://grokzilla.shop/docs/seo-v2 |
| seo_compare | POST /api/skills/seo-compare | $0.0503 | https://grokzilla.shop/docs/seo-v2 |
| agent_ready_audit | POST /api/skills/agent-ready-audit | $0.1993 | https://grokzilla.shop/docs/agent-ready |
| agent_ready_kit | POST /api/skills/agent-ready-kit | $0.2502 | https://grokzilla.shop/docs/agent-ready |
| agent_ready_recheck | POST /api/skills/agent-ready-recheck | $0.0102 | https://grokzilla.shop/docs/agent-ready |
| ai_detector | POST /api/skills/ai-detector | $0.01 | https://grokzilla.shop/docs/ai-detector |
| json_flatten | POST /api/skills/json-flatten | $0.006 | https://grokzilla.shop/docs/json-flatten |
| json_sort | POST /api/skills/json-sort | $0.003 | https://grokzilla.shop/docs/json-sort |
| text_diff | POST /api/skills/text-diff | $0.006 | https://grokzilla.shop/docs/text-diff |
| url_normalize | POST /api/skills/url-normalize | $0.005 | https://grokzilla.shop/docs/url-normalize |
| html_clean | POST /api/skills/html-clean | $0.008 | https://grokzilla.shop/docs/html-clean |
| json_schema_validate | POST /api/skills/json-schema-validate | $0.006 | https://grokzilla.shop/docs/json-schema-validate |
| keyword_extract | POST /api/skills/keyword-extract | $0.008 | https://grokzilla.shop/docs/keyword-extract |
| token_count | POST /api/skills/token-count | $0.004 | https://grokzilla.shop/docs/token-count |
| sha256 | POST /api/skills/sha256 | $0.003 | https://grokzilla.shop/docs/sha256 |
| uuid_mint | POST /api/skills/uuid-mint | $0.003 | https://grokzilla.shop/docs/uuid-mint |
| slugify | POST /api/skills/slugify | $0.003 | https://grokzilla.shop/docs/slugify |
| pii_redact | POST /api/skills/pii-redact | $0.003 | https://grokzilla.shop/docs/pii-redact |
| csv_normalize | POST /api/skills/csv-normalize | $0.003 | https://grokzilla.shop/docs/csv-normalize |
| base64 | POST /api/skills/base64 | $0.003 | https://grokzilla.shop/docs/base64 |
| epoch_convert | POST /api/skills/epoch-convert | $0.003 | https://grokzilla.shop/docs/epoch-convert |
| url_to_markdown | POST /api/skills/url-to-markdown | $0.003 | https://grokzilla.shop/docs/url-to-markdown |
| token_risk | POST /api/skills/token-risk | $0.005 | https://grokzilla.shop/docs/token-risk |
| json_repair | POST /api/skills/json-repair | $0.0041 | https://grokzilla.shop/docs/json-repair |
| cron_next | POST /api/skills/cron-next | $0.0031 | https://grokzilla.shop/docs/cron-next |
| token_price | POST /api/skills/token-price | $0.002 | https://grokzilla.shop/docs/token-price |
| email_check | POST /api/skills/email-check | $0.0032 | https://grokzilla.shop/docs/email-check |
| news_brief | POST /api/skills/news-brief | $0.0101 | https://grokzilla.shop/docs/news-brief |
| ip_intel | POST /api/skills/ip-intel | $0.0033 | https://grokzilla.shop/docs/ip-intel |
| llm_cost_quote | POST /api/skills/llm-cost-quote | $0.0034 | https://grokzilla.shop/docs/llm-cost-quote |
| phone_normalize | POST /api/skills/phone-normalize | $0.0021 | https://grokzilla.shop/docs/phone-normalize |
## FAQ
Q: Do I need an account or API key?
A: No. Every paid route answers an unpaid POST with HTTP 402 and the payment terms; any x402 v2 client can pay and retry. There is no signup.
Q: Which network and asset?
A: USDC on Base mainnet (eip155:8453), x402 v2 with the exact scheme.
Q: What does a call cost?
A: Between $0.002 and $0.1993 per call, listed per skill in the table on this page, at /pricing and in /api/catalog. A $1 credit pack buys 300 calls of any skill listed at $0.005 or less.
Q: Is there a free tier?
A: No. Free beta is off; every skill call is paid. The discovery files (catalog, manifest, OpenAPI, llms.txt) are free to read.
Q: Does the server accept x402 v1?
A: No. The server is x402 v2 only; a v1 payment header gets a 402 back with the v2 terms.
Q: Can humans pay without a crypto wallet?
A: Yes, through Stripe checkout on the site (see /pricing for the minimum).
## llms.txt
# grokzilla.shop / x402-micro-pay.com
> Humanless microservices marketplace for AI agents. Pay-per-call with x402 (USDC on Base mainnet eip155:8453). Humans can also pay with Stripe.
## Identity
- Primary (canonical): https://grokzilla.shop
- Alias (same content, canonical points to primary): https://x402-micro-pay.com
- Protocol: x402 v2 exact scheme
- Network: eip155:8453 (Base mainnet)
- Asset: USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
- Billing: paid only (free_beta: false)
## Critical agent endpoints (start here)
- Try first (cheapest paid call): POST https://grokzilla.shop/api/skills/uuid-mint
Body: {"count":1,"version":4} · Price: $0.003 USDC on Base (atomic 3000) · payTo 0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69
Buyer gets: {"ok":true,"ids":["…uuid v4…"],"skill":"uuid_mint",…} for job IDs / idempotency keys
Flow: unpaid POST → 402 + PAYMENT-REQUIRED → PAYMENT-SIGNATURE retry
- Manifest: https://grokzilla.shop/.well-known/x402
- Catalog (JSON): https://grokzilla.shop/api/catalog
- OpenAPI: https://grokzilla.shop/openapi.json
- Humanless contract: https://grokzilla.shop/contracts/humanless.json
- Health: https://grokzilla.shop/health
- MCP (Streamable HTTP, JSON): https://grokzilla.shop/mcp
- MCP quickstart: https://grokzilla.shop/agents (markdown: https://grokzilla.shop/agents.md)
- MCP discovery: https://grokzilla.shop/.well-known/mcp · server card: https://grokzilla.shop/.well-known/mcp/server-card.json
- Pricing: https://grokzilla.shop/pricing
- Terms: https://grokzilla.shop/terms
- Daily utils (first-party): POST /api/skills/json-flatten, /api/skills/text-diff, /api/skills/url-normalize, /api/skills/html-clean, /api/skills/json-schema-validate, /api/skills/keyword-extract, /api/skills/token-count, /api/skills/json-sort ($0.003), /api/skills/sha256 ($0.003), /api/skills/uuid-mint ($0.003), /api/skills/slugify ($0.003), /api/skills/pii-redact ($0.003), /api/skills/csv-normalize ($0.003), /api/skills/base64 ($0.003), /api/skills/epoch-convert ($0.003), /api/skills/url-to-markdown ($0.003), /api/skills/token-risk ($0.005), /api/skills/json-repair ($0.0041), /api/skills/cron-next ($0.0031)
- Data services (free public sources, not charged on empty/failed): POST /api/skills/token-price ($0.002), /api/skills/email-check ($0.0032), /api/skills/news-brief ($0.0101), /api/skills/ip-intel ($0.0033), /api/skills/llm-cost-quote ($0.0034), /api/skills/phone-normalize ($0.0021)
## How agents pay
1. GET /.well-known/x402 or /api/catalog for services + prices.
2. POST a skill endpoint. Unpaid calls return HTTP 402 + PAYMENT-REQUIRED header.
3. Sign exact USDC payment to the pay_to address on Base mainnet, retry with PAYMENT-SIGNATURE.
4. Receive JSON result. Respect max_spend_per_call / max_spend_per_session in humanless.json.
## MCP
Streamable HTTP JSON-RPC at https://grokzilla.shop/mcp. Quickstart: https://grokzilla.shop/agents. Guides: https://grokzilla.shop/docs/mcp. Discovery tools (`list_skills`, `get_skill`) are free. Paid tools use the same x402 prices as the HTTP routes (USDC on Base). A client that cannot attach an x402 payment receives a PaymentRequired tool result and should stop. The server does not pay and does not hold a wallet key.
## Native skills (paid, Base mainnet)
| id | method | endpoint | typical price |
|----|--------|----------|---------------|
| osint_graph | POST | /api/skills/osint-graph | $0.01 |
| seo | POST | /api/skills/seo | $0.012 |
| seo_v2 | POST | /api/skills/seo-v2 | $0.0997 |
| seo_compare | POST | /api/skills/seo-compare | $0.0503 |
| agent_ready_audit | POST | /api/skills/agent-ready-audit | $0.1993 |
| agent_ready_kit | POST | /api/skills/agent-ready-kit | $0.2502 |
| agent_ready_recheck | POST | /api/skills/agent-ready-recheck | $0.0102 |
| ai_detector | POST | /api/skills/ai-detector | $0.01 |
| json_flatten | POST | /api/skills/json-flatten | $0.006 |
| json_sort | POST | /api/skills/json-sort | $0.003 |
| text_diff | POST | /api/skills/text-diff | $0.006 |
| url_normalize | POST | /api/skills/url-normalize | $0.005 |
| html_clean | POST | /api/skills/html-clean | $0.008 |
| json_schema_validate | POST | /api/skills/json-schema-validate | $0.006 |
| keyword_extract | POST | /api/skills/keyword-extract | $0.008 |
| token_count | POST | /api/skills/token-count | $0.004 |
| sha256 | POST | /api/skills/sha256 | $0.003 |
| uuid_mint | POST | /api/skills/uuid-mint | $0.003 |
| slugify | POST | /api/skills/slugify | $0.003 |
| pii_redact | POST | /api/skills/pii-redact | $0.003 |
| csv_normalize | POST | /api/skills/csv-normalize | $0.003 |
| base64 | POST | /api/skills/base64 | $0.003 |
| epoch_convert | POST | /api/skills/epoch-convert | $0.003 |
| url_to_markdown | POST | /api/skills/url-to-markdown | $0.003 |
| token_risk | POST | /api/skills/token-risk | $0.005 |
| json_repair | POST | /api/skills/json-repair | $0.0041 |
| cron_next | POST | /api/skills/cron-next | $0.0031 |
| token_price | POST | /api/skills/token-price | $0.002 |
| email_check | POST | /api/skills/email-check | $0.0032 |
| news_brief | POST | /api/skills/news-brief | $0.0101 |
| ip_intel | POST | /api/skills/ip-intel | $0.0033 |
| llm_cost_quote | POST | /api/skills/llm-cost-quote | $0.0034 |
| phone_normalize | POST | /api/skills/phone-normalize | $0.0021 |
Exact live prices: GET /api/catalog (price_usd). Every call is paid. 402 responses include JSON body + PAYMENT-REQUIRED header.
## Partner resale (separate group; resold partner services)
Resold partner services (provider x402-mcp.onrender.com, not ours). GET with query params, paid per call via x402 on Base. Your payment settles first; if the partner then fails you get charged:true plus a full refund record. Output is normalized to grokzilla.partner-resale.v1. Separate from the native skills list.
| id | method | endpoint | price | query params (* required) |
|----|--------|----------|-------|---------------------------|
| base-tx-decision | GET | /api/resale/base/tx-decision | $0.020001 (20001 atomic) | gas, urgency |
| base-finality-check | GET | /api/resale/base/finality-check | $0.020002 (20002 atomic) | tx* |
| nyc-property-check | GET | /api/resale/us/nyc/property-check | $0.020003 (20003 atomic) | address* |
| mn-property-check | GET | /api/resale/mn/property-check | $0.020004 (20004 atomic) | address* |
Output: JSON, schema `grokzilla.partner-resale.v1` (envelope ok/schema/route/provider/subject/verdict/status/summary/risk_flags/evidence/sources/disclaimer/checked_at/upstream_tx + route-specific `data`). Full JSON Schemas: GET /api/catalog (partner_resale.services[].output_schema). These are not MCP tools and not in the native skills count.
## Kits (one-time download, x402)
- [Domain-to-Vercel MCP kit (bring your own keys)](https://grokzilla.shop/kits/domain-to-vercel): $5.00 USDC on Base. `POST https://grokzilla.shop/api/kits/domain-to-vercel/buy` returns a download link (expires 15 min, 3 downloads). License: [No-Resale](https://grokzilla.shop/kits/license).
## Credit pack
- POST /api/credits/buy — Credit pack: 300 calls of any skill listed at $0.005 or less, for one $1.00 x402 payment. Returns a token (shown once) for the X-Credit-Token header. Failed calls use no credit. Expires after 180 days.
- GET /api/credits/balance (header X-Credit-Token) — free balance check.
## Skill notes
- ai_detector ($0.01): trained classifier, about 78% accurate on a held-out benchmark (not a guarantee). `uncertain` results suggest a rerun on a longer section (300+ words). Tell phrases are only a secondary "possible AI influence" signal.
- seo_v2 / seo_compare / agent_ready_audit / agent_ready_kit / agent_ready_recheck: not charged when the site blocks us or is unreachable (422, score null, charged:false; payment is never settled). Agent-Ready inputs: `override_full_disallow` (bool, default false: never open a site-wide `Disallow: /` to AI bots unless true), `runs_a2a_agent` (bool, default false: agent-card.json only if true). Recheck needs `report_id` (400 before payment). Docs: https://grokzilla.shop/docs/seo-v2 and https://grokzilla.shop/docs/agent-ready
## Docs for agents
- AGENTS.md: https://grokzilla.shop/AGENTS.md
- Tutorials: https://grokzilla.shop/docs
- MCP guides: https://grokzilla.shop/docs/mcp
- Your agent pays for a tool call in 30 seconds: https://grokzilla.shop/docs/mcp/agent-pays-in-30-seconds
- A paid MCP tool call, step by step: https://grokzilla.shop/docs/mcp/mcp-paid-call-example
- Capping what your agent spends (per-call cap, daily budget): https://grokzilla.shop/docs/mcp/spend-limits
- Quickstart (prose): https://grokzilla.shop/quickstart
- Full text for LLMs: https://grokzilla.shop/llms-full.txt
- Source: https://github.com/nicsins/ai-micro-pay
## Doc: https://grokzilla.shop/docs/agent-ready
# Agent-Ready Website Kit
Make a site readable for AI crawlers and agents. Give us a URL. We check how 17 AI crawlers and agents (GPTBot, ClaudeBot, Claude-SearchBot, OAI-SearchBot, PerplexityBot, Google-Extended, ChatGPT-User, Perplexity-User and more) can reach the site, including live user-agent probes that catch firewall blocks robots.txt doesn't show, score six areas and generate ready-to-install files. This removes technical barriers. It can't guarantee that any AI system will crawl, rank, cite, or send traffic to your site.
## Calls
| Route | Price | What you get |
|---|---|---|
| `POST /api/skills/agent-ready-audit` | $0.1993 (199300 atomic) | score, per-bot table, checks with fixes, preview of llms.txt and the robots AI block |
| `POST /api/skills/agent-ready-kit` | $0.2502 (250200 atomic) | the audit plus every generated file and a zip (base64) |
| `POST /api/skills/agent-ready-recheck` | $0.0102 (10200 atomic) | `{"report_id"}` from an audit in the last 30 days: re-audit + what got fixed or regressed |
| `GET /api/skills/agent-ready/sample` | free | full example report for a demo site |
**License:** the kit zip is covered by the [Grokzilla No-Resale License](/kits/license) (included as `LICENSE.md`). Use and change the files for your own sites and client work; don't resell or republish the kit as a kit or template.
```json
{"url": "https://example.com/", "max_pages": 10, "crawler_policy": "allow_search_block_training",
"business": {"name": "Example Co", "logo": "https://example.com/logo.png", "same_as": ["https://x.com/example"]}}
```
- `site_type`: auto, saas, api, ecommerce, publisher, local_business, docs.
- `crawler_policy`: `allow_all_ai`, `allow_search_block_training` (default: search and user-triggered agents must be allowed; blocking training bots is your choice and is not penalized) or `custom` with `custom_policy: {"GPTBot": "block", ...}`.
- `business`: facts for the generated files. Anything missing stays `TODO`; nothing is invented.
- `max_pages`: 1-25 (default 10), sampled from your sitemap and homepage links.
- `render_js`: not available yet; `true` is refused with 400 before payment.
- `override_full_disallow` (boolean, default `false`): if your robots.txt says `Disallow: /` for everyone, the generated robots.txt does not open the site to the AI bots your policy allows. It adds a WARNING line and a conflict note in INSTALL.md instead. Send `true` only if you really want those bots allowed despite the site-wide block. Non-boolean values get 400 before payment.
- `runs_a2a_agent` (boolean, default `false`): send `true` only if the site really runs an A2A agent. Then the kit generates `.well-known/agent-card.json` and the agent card is scored; otherwise it is N/A and costs no points.
## Rubric (100 points)
Crawler access 30 (robots.txt, per-bot policy match, live UA probes, noindex), machine-readable summary 15 (llms.txt per llmstxt.org v2, llms-full.txt, llms.txt links resolve), structured data 20, discoverability 15 (sitemap, canonical host, meta/OG), content readability 10, agent interfaces 10 (OpenAPI, A2A agent card, MCP, /.well-known/x402). Agent interfaces are N/A for sites without an API, and the score is reweighted.
## Generated files (kit)
llms.txt, llms-full.txt, robots.txt (your existing rules kept verbatim, AI block appended; allowed bots repeat your `User-agent: *` rules because a named group replaces it under RFC 9309), sitemap.xml (audited host only), JSON-LD and meta/OG per page, `.well-known/agent-card.json` (only if you run an A2A agent), OpenAPI hints, and INSTALL.md with Cloudflare/Vercel firewall notes when probes are blocked. `ai-plugin.json` is never generated (ChatGPT plugins were retired in 2024).
Probes are sent from our servers with each bot's published user-agent string. CDNs that verify real crawlers by IP can treat that differently from the real bot, so a block is strong evidence, not proof.
## Errors (not charged)
`400` before payment: invalid/private/loopback URL, the marketplace's own hosts, bad enum values, `max_pages` over 25, non-boolean `override_full_disallow`/`runs_a2a_agent`, a recheck without `report_id`, an invalid or expired `report_id`.
**Blocked or unreachable sites are not charged.** Your payment is verified first and only settled after a real result (a non-null score). If the site blocks us (403/429/challenge page) or is unreachable, you get `422` with the blocked result (`score: null`, `status`, `reason`) and `charged: false`, and the payment is never settled. If settlement fails after a good result, you get `402` and no result.
## Doc: https://grokzilla.shop/docs/ai-detector
# AI Content Detector
Estimate whether text, or the text of a web page, was written by an AI assistant. The result is a stylometric score, the signals behind it, and a band around the score. It does not judge images or other media.
Send exactly one of `text` or `url`. Under 80 words the verdict is `uncertain`. Detection is probabilistic and should not be the only evidence.
## Step 1 — Text
```bash
curl -s -X POST https://x402-micro-pay.com/api/skills/ai-detector \
-H "Content-Type: application/json" \
-d '{"text":"Paste a passage of at least a few sentences."}'
```
A short snippet still returns signals, and the verdict stays `uncertain` until there are 80 words.
## Step 2 — URL
```bash
curl -s -X POST https://x402-micro-pay.com/api/skills/ai-detector \
-H "Content-Type: application/json" \
-d '{"url":"https://www.gutenberg.org/files/1342/1342-h/1342-h.htm"}'
```
The page is fetched and its text is scored. A page that cannot be fetched, or that has no text, returns `uncertain` and a `reason`. No sample paragraph is substituted.
## Step 3 — Agent
```bash
python -m agent.humanless_client ai_detector --text "Paste a passage of at least a few sentences."
```
## Output fields
- `verdict` — `likely_ai`, `likely_human`, or `uncertain`. `likely_human` needs a low score and positive human evidence (contractions, uneven sentence lengths, or verse). A low score without that evidence is `uncertain`, because plain model output without stock phrases can also score low.
- `ai_likelihood` — stylometric score from 0 to 1, or null when nothing could be scored
- `band` — low and high around that score, or null when nothing could be scored
- `signals` — sentence length and variance, burstiness, type-token ratio, hapax ratio, punctuation diversity, repeated n-grams, stock phrases per 100 words, contraction rate, average word length, and line-length uniformity
- `method` — `stylometry`, or `stylometry+llm` when `OPENROUTER_API_KEY` is set and a second opinion comes back
- `word_count`
- `caveats` — always includes a note that detection is probabilistic
- `reason` — present when a URL could not be scored
`ai_likelihood` is not a calibrated probability. The optional model check, when configured, is blended at a weight of 0.25 and reported under `llm`.
## The 4-section rubric
The verdict comes from a fixed, deterministic rubric. Each section returns
`human_sign`, `ai_sign` or `no_signal` with evidence.
| Section | Weight | Looks at |
|---|---|---|
| rhythm | 10% | sentence-length variance and burstiness |
| vocabulary | 40% | a weighted list of LLM tell phrases (secondary signal) |
| voice_structure | 30% | hedging, distancing, over-tidy transitions, uniform paragraphs, missing specifics vs. first person, dialogue, names, asides |
| resolution | 20% | each section re-checks its neighbour |
`likely_ai` or `likely_human` needs at least two sections agreeing with
positive evidence and none pointing the other way. Tell phrases alone never
decide: unconfirmed tells give `possible_ai_influence`. Disagreement gives
`uncertain`. `content_type` (story, opinion, factual_claims) is a label only;
nothing is fact-checked. `ai_likelihood` is still the stylometric score.
## Doc: https://grokzilla.shop/docs/base64
# Base64 Encode/Decode
Base64-encode UTF-8 text or decode base64 back to text. Standard or URL-safe alphabet. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/base64`
```json
{ "mode": "encode", "text": "hello agent", "url_safe": false }
```
`mode` (required: `"encode"` or `"decode"`), `text` (required string, up to 400,000 characters), `url_safe` (optional boolean, default `false`: use `-` and `_` instead of `+` and `/`).
Decoding ignores whitespace and accepts missing `=` padding. The decoded bytes must be UTF-8 text.
## Errors (not charged)
- `422 invalid_params`: missing `mode`/`text`, `mode` not `encode`/`decode`, wrong types, over the size cap.
- `400`: `invalid_base64` (characters outside the alphabet, impossible length), `not_utf8` (decoded bytes are not text).
## Response (paid 200)
```json
{
"skill": "base64",
"ok": true,
"mode": "encode",
"url_safe": false,
"output": "aGVsbG8gYWdlbnQ=",
"bytes": 11
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/cron-next
# Cron Next Runs
Validate a cron expression and get its next run times in any IANA time zone. DST-aware, deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/cron-next`
```json
{"expr": "*/15 9-17 * * MON-FRI", "tz": "America/Chicago", "count": 3, "from": "2026-10-16T12:42:00-05:00"}
```
- `expr` (required): five fields `minute hour day-of-month month day-of-week`. Supports `*`, lists (`1,15`), ranges (`9-17`), steps (`*/15`, `0-30/10`), names (`JAN`-`DEC`, `SUN`-`SAT`), `7` = Sunday, and the macros `@yearly` `@annually` `@monthly` `@weekly` `@daily` `@midnight` `@hourly`.
- `tz` (optional IANA zone, default `UTC`).
- `count` (optional 1 to 20, default 5).
- `from` (optional ISO-8601 start; a time without an offset is read in `tz`). Runs strictly after it are returned. Default: now.
Cron rules: when both day-of-month and day-of-week are restricted, a day matches if either matches. Times are wall-clock in `tz`: a time skipped by a DST jump does not fire, and a repeated hour fires once.
## Errors (not charged)
- `422 invalid_params`: missing `expr`, `count` outside 1 to 20, wrong types.
- `400`: `bad_cron` (with the field and reason), `unknown_tz`, `bad_from`, `no_match` (the schedule can never fire, e.g. Feb 30).
## Response (paid 200)
```json
{
"skill": "cron_next",
"ok": true,
"expr": "*/15 9-17 * * MON-FRI",
"normalized": "*/15 9-17 * * MON-FRI",
"tz": "America/Chicago",
"from": "2026-10-16T12:42:00-05:00",
"count": 3,
"next": [
"2026-10-16T12:45:00-05:00",
"2026-10-16T13:00:00-05:00",
"2026-10-16T13:15:00-05:00"
],
"next_utc": [
"2026-10-16T17:45:00Z",
"2026-10-16T18:00:00Z",
"2026-10-16T18:15:00Z"
],
"next_epoch_s": [
1792172700,
1792173600,
1792174500
],
"fields": {
"minute": [
0,
15,
30,
45
],
"hour": [
9,
10,
11,
12,
13,
14,
15,
16,
17
],
"day_of_month": [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31
],
"month": [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
],
"day_of_week": [
1,
2,
3,
4,
5
]
}
}
```
Unpaid → HTTP 402 (x402 v2 exact, USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.0031 per call (3100 atomic USDC).
## Doc: https://grokzilla.shop/docs/csv-normalize
# CSV Normalizer
Parse CSV text into JSON rows keyed by clean snake_case headers. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/csv-normalize`
```json
{ "csv": "First Name,E-mail\nAda,ada@example.com\n", "delimiter": "," }
```
`csv` (required string, 1-400,000 characters, first non-blank row is the header), `delimiter` (optional: `","` default, `";"`, `"\t"`, `"|"`).
- Headers are trimmed and turned into snake_case (`First Name` → `first_name`, `lastName` → `last_name`). Empty headers become `column_N`; duplicates get `_2`, `_3`.
- Cell values are trimmed strings (no type guessing). Blank lines are skipped. A UTF-8 BOM is ignored.
- Limits: 10,000 data rows, 256 columns.
## Errors (not charged)
- `422 invalid_params`: missing or non-string `csv`, empty `csv`, unsupported `delimiter`, over the size cap.
- `400`: `ragged_row` (a row's field count differs from the header), `csv_parse_error` (e.g. unterminated quote), `empty_csv`, `too_many_rows`, `too_many_columns`.
## Response (paid 200)
```json
{
"skill": "csv_normalize",
"ok": true,
"headers": ["first_name", "e_mail"],
"rows": [{"first_name": "Ada", "e_mail": "ada@example.com"}],
"row_count": 1
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/email-check
# Email Deliverability Check
Check an email address for deliverability: syntax, canonical form, MX, SPF, DMARC, disposable domain. One verdict with reasons and sources. DNS-over-HTTPS only, no mailbox probing. Not charged if the DNS lookup fails.
Price: **$0.0032** per call, USDC on Base (x402). Also available as the MCP tool `email_check` at https://grokzilla.shop/mcp.
Public DNS only, over DNS-over-HTTPS (Cloudflare, Google as fallback): MX (null MX per RFC 7505, implicit MX via A), SPF, DMARC, plus a disposable-domain flag from the CC0 [disposable-email-domains](https://github.com/disposable-email-domains/disposable-email-domains) list. **No SMTP connection and no mailbox probing**, so `mailbox_checked` is always false: a deliverable domain can still reject one mailbox.
Verdicts: `deliverable` (MX ok), `risky` (implicit MX, unresolvable MX host, or disposable domain), `undeliverable` (NXDOMAIN, null MX, or nowhere to deliver).
## Call
`POST /api/skills/email-check`
```json
{"email": "jane.doe+news@gmail.com"}
```
- `email` (required): string
- `request_id` (optional): Optional idempotency key. Echoed back; a credit-pack redemption with the same request_id and body is charged once.
## Not charged
Every non-200 has `charged: false` and is never settled.
- `422 invalid_params` / `400 invalid_params`: body fails the schema (checked before the 402).
- `400` before payment: not an address, IP-literal or private/reserved domains (.local, .internal, .test …).
- `503 dns_unavailable`: no DoH resolver answered.
## Response (paid 200)
Same envelope on every data service: `ok, service, version, summary, data, confidence, sources, generated_at, data_as_of, charged, warnings, next`.
```json
{
"ok": true,
"skill": "email_check",
"service": "email_check",
"version": "1.0.0",
"summary": "deliverable: MX ok (gmail-smtp-in.l.google.com), SPF ok, DMARC p=none",
"data": {
"email": "jane.doe+news@gmail.com",
"local": "jane.doe+news",
"domain": "gmail.com",
"verdict": "deliverable",
"reasons": [
"MX ok (gmail-smtp-in.l.google.com)",
"SPF ok",
"DMARC p=none"
],
"syntax_valid": true,
"canonical": "janedoe@gmail.com",
"canonical_rule": "gmail: dots and +tag removed",
"plus_tag": "news",
"domain_exists": true,
"mx": [
{
"priority": 5,
"host": "gmail-smtp-in.l.google.com"
},
{
"priority": 10,
"host": "alt1.gmail-smtp-in.l.google.com"
},
{
"priority": 20,
"host": "alt2.gmail-smtp-in.l.google.com"
},
{
"priority": 30,
"host": "alt3.gmail-smtp-in.l.google.com"
},
{
"priority": 40,
"host": "alt4.gmail-smtp-in.l.google.com"
}
],
"null_mx": false,
"implicit_mx": false,
"mx_host_resolves": true,
"spf": {
"present": true,
"record": "v=spf1 redirect=_spf.google.com",
"count": 1
},
"dmarc": {
"present": true,
"record": "v=DMARC1; p=none; sp=quarantine; rua=mailto:mailauth-reports@google.com",
"p": "none",
"sp": "quarantine",
"pct": null,
"rua": true
},
"disposable": false,
"role_account": false,
"free_provider": true,
"mailbox_checked": false
},
"confidence": 0.85,
"sources": [
{
"name": "Cloudflare DoH",
"url": "https://cloudflare-dns.com/dns-query?name=gmail.com",
"fetched_at": "2026-10-17T11:12:49Z"
},
{
"name": "disposable-email-domains",
"url": "https://github.com/disposable-email-domains/disposable-email-domains (CC0-1.0)",
"fetched_at": "2026-10-17T11:12:49Z",
"list_date": "2026-10-16"
}
],
"generated_at": "2026-10-17T11:12:49Z",
"data_as_of": "2026-10-17T11:12:49Z",
"charged": true,
"warnings": [
"mailbox existence is not checked (no SMTP probing); a deliverable domain can still reject this mailbox"
],
"next": [
"phone_normalize",
"ip_intel"
]
}
```
## Doc: https://grokzilla.shop/docs/epoch-convert
# Epoch Converter
Convert between Unix epoch time and ISO-8601, in UTC and any IANA time zone. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/epoch-convert`
```json
{"value": 1700000000, "tz": "America/Chicago"}
```
`value` (required: number, numeric string, or ISO-8601 string up to 64 characters), `tz` (optional IANA zone, default `UTC`).
Numbers are read by magnitude: below 1e11 seconds, below 1e14 milliseconds, below 1e17 microseconds, otherwise nanoseconds (`input_kind` says which). An ISO string without an offset is read in `tz`. `epoch_s` is an integer for whole seconds, else a decimal with millisecond precision.
## Errors (not charged)
- `422 invalid_params`: missing `value`, booleans/arrays/null, empty `tz`, over the size caps.
- `400`: `unknown_tz`, `bad_iso`, `bad_value`, `out_of_range` (outside years 1 to 9999).
## Response (paid 200)
```json
{
"skill": "epoch_convert",
"ok": true,
"input_kind": "epoch_s",
"epoch_s": 1700000000,
"epoch_ms": 1700000000000,
"iso_utc": "2023-11-14T22:13:20Z",
"iso_tz": "2023-11-14T16:13:20-06:00",
"tz": "America/Chicago",
"utc_offset": "-06:00"
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/first-agent-call
# Tutorial – Your First Paid Agent Call
**Goal:** Make one successful paid call to a skill and confirm it was logged.
## Prerequisites
- Valid agent identity
- Ability to complete an x402 payment (or use test mode)
- Access to the live endpoints
## Steps
1. Discover available skills: `GET https://x402-micro-pay.com/api/catalog`
2. Read the specific tutorial for the skill under `/docs`
3. Complete payment (x402 or Stripe when enabled)
4. Call the skill endpoint with required payload
5. Receive structured result
## Common Pitfalls
- Missing or expired payment proof → 402
- Hitting rate limit → 429
- Wrong payload shape → validation error
Once this works, explore batch calls and opportunity signals from the call log.
## Doc: https://grokzilla.shop/docs/html-clean
# HTML Cleaner
POST `/api/skills/html-clean` — $0.008 USDC on Base.
```json
{ "html": "Hi
Keep me
", "mode": "markdown" }
```
Returns stripped text or markdown. Scripts and styles are dropped.
## Doc: https://grokzilla.shop/docs/ip-intel
# IP & CIDR Intel
One public IP or CIDR in: normalized network, size, membership checks, plus holder, abuse contact and origin ASN from RIR RDAP and RIPEstat, and country from DB-IP Lite (CC BY 4.0, attributed). Private ranges refused before payment. Not charged if registries fail.
Price: **$0.0033** per call, USDC on Base (x402). Also available as the MCP tool `ip_intel` at https://grokzilla.shop/mcp.
Deterministic network facts (version, normalized network, size, first/last address, optional membership `check`) plus live registry data: RIR RDAP via the rdap.org bootstrap (holder, network name, registered range, abuse email) and RIPEstat (origin ASN, routed prefix, AS holder). Country comes from the bundled **DB-IP IP-to-Country Lite** dataset, licensed CC BY 4.0: every response carries the attribution "IP Geolocation by DB-IP" (https://db-ip.com) and the dataset month. No MaxMind data.
## Call
`POST /api/skills/ip-intel`
```json
{"query": "8.8.8.8"}
```
- `query` (required): IPv4/IPv6 address or CIDR
- `check` (optional): IPs to test for membership in the network
- `request_id` (optional): Optional idempotency key. Echoed back; a credit-pack redemption with the same request_id and body is charged once.
## Not charged
Every non-200 has `charged: false` and is never settled.
- `422 invalid_params` / `400 invalid_params`: body fails the schema (checked before the 402).
- `400` before payment: private, loopback, link-local, CGNAT, documentation, multicast and other non-global ranges; prefixes shorter than /8 (IPv4) or /16 (IPv6); IPv4-mapped IPv6.
- `503 registry_unavailable`: neither RDAP nor RIPEstat answered.
## Response (paid 200)
Same envelope on every data service: `ok, service, version, summary, data, confidence, sources, generated_at, data_as_of, charged, warnings, next`.
```json
{
"ok": true,
"skill": "ip_intel",
"service": "ip_intel",
"version": "1.0.0",
"summary": "8.8.8.8/32: AS15169 GOOGLE - Google LLC, Google LLC, US",
"data": {
"network": {
"query": "8.8.8.8",
"version": 4,
"network": "8.8.8.8/32",
"prefix_length": 32,
"num_addresses": "1",
"first": "8.8.8.8",
"last": "8.8.8.8",
"is_single_address": true,
"is_global": true,
"reverse_pointer": "8.8.8.8.in-addr.arpa"
},
"registry": {
"handle": "NET-8-8-8-0-2",
"name": "GOGL",
"holder": "Google LLC",
"type": "DIRECT ALLOCATION",
"start_address": "8.8.8.0",
"end_address": "8.8.8.255",
"cidrs": [
"8.8.8.0/24"
],
"registry_country": null,
"abuse_email": "network-abuse@google.com",
"registered": "2023-12-28T17:24:33-05:00",
"last_changed": "2023-12-28T17:24:56-05:00",
"origin_asns_registered": null
},
"routing": {
"asns": [
15169
],
"routed_prefix": "8.8.8.0/24",
"as_holder": "GOOGLE - Google LLC"
},
"geo": {
"country": "US",
"countries_at_edges": [
"US"
],
"dataset": "DB-IP IP-to-Country Lite 2026-10",
"attribution": {
"text": "IP Geolocation by DB-IP",
"url": "https://db-ip.com",
"license": "CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)"
}
}
},
"confidence": 0.9,
"sources": [
{
"name": "RIR RDAP (via rdap.org bootstrap)",
"url": "https://rdap.arin.net/registry/ip/8.8.8.8",
"fetched_at": "2026-10-17T11:12:56Z"
},
{
"name": "RIPEstat network-info / as-overview",
"url": "https://stat.ripe.net/data/network-info/data.json?resource=8.8.8.8",
"fetched_at": "2026-10-17T11:12:56Z"
},
{
"name": "IP Geolocation by DB-IP",
"url": "https://db-ip.com",
"fetched_at": "2026-10-17T11:12:56Z",
"dataset_month": "2026-10",
"license": "CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)"
}
],
"generated_at": "2026-10-17T11:12:56Z",
"data_as_of": "2026-10-17T11:12:56Z",
"charged": true,
"warnings": [
"country is DB-IP Lite geolocation (country-level, monthly); it can differ from the registry country"
],
"next": [
"email_check"
],
"attribution": {
"text": "IP Geolocation by DB-IP",
"url": "https://db-ip.com",
"license": "CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)"
}
}
```
## Doc: https://grokzilla.shop/docs/json-flatten
# JSON Flattener
Deterministic nested JSON → flat path-value map. First-party on grokzilla.shop.
## Call
`POST /api/skills/json-flatten`
```json
{
"data": { "user": { "id": 7, "tags": ["a", "b"] } },
"options": { "separator": ".", "arrayStyle": "index", "maxDepth": 20 }
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`.
Price: $0.01 per call.
## Doc: https://grokzilla.shop/docs/json-repair
# JSON Repair
Fix the almost-JSON that LLMs, JavaScript and Python emit, and get back valid JSON plus a list of exactly what was fixed. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/json-repair`
```json
{"text": "{name: 'Ada', tags: ['math', 'code',], active: True, // note\n}"}
```
`text` (required string, 1 to 400,000 characters).
Fixes: `stripped_code_fence` (```json fences), `removed_comments` (`//` and `/* */`), `trailing_commas`, `single_quotes`, `unquoted_keys`, `python_literals` (True/False/None), `missing_commas` (between object members), `escaped_newlines_in_strings`, and `closed_unterminated` (truncated output: open strings, objects and arrays are closed; a dangling key at the cut is dropped). Valid JSON passes through with `fixes: []` and `changed: false`.
## Errors (not charged)
- `422 invalid_params`: missing or empty `text`, non-string `text`, over the size cap.
- `400`: `unrepairable_json` (with line and character), `empty_input`.
## Response (paid 200)
`json` is the parsed value; `repaired` is the same value as compact JSON text.
```json
{
"skill": "json_repair",
"ok": true,
"json": {
"name": "Ada",
"tags": [
"math",
"code"
],
"active": true
},
"repaired": "{\"name\":\"Ada\",\"tags\":[\"math\",\"code\"],\"active\":true}",
"fixes": [
"unquoted_keys",
"single_quotes",
"trailing_commas",
"python_literals",
"removed_comments"
],
"changed": true
}
```
Unpaid → HTTP 402 (x402 v2 exact, USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.0041 per call (4100 atomic USDC).
## Doc: https://grokzilla.shop/docs/json-schema-validate
# JSON Schema Validator
POST `/api/skills/json-schema-validate` — $0.006 USDC on Base.
```json
{
"instance": { "id": 1 },
"schema": { "type": "object", "required": ["id"], "properties": { "id": { "type": "number" } } }
}
```
Use this as a cheap gate before paying a larger model.
`ok` means the check ran. `valid` means the instance matched the schema. An invalid instance is `ok: true`, `valid: false`, with `errors` filled. `ok: false` means the schema could not be checked (it is not an object, or a nested schema keyword is the wrong type).
## Doc: https://grokzilla.shop/docs/json-sort
# JSON Key Sorter
Recursively sort object keys and return canonical compact JSON. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/json-sort`
```json
{ "data": { "b": 1, "a": { "d": 2, "c": 3 } }, "reverse": false }
```
`data` (required, any JSON), `reverse` (optional boolean, default `false`).
## Response (paid 200)
```json
{
"skill": "json_sort",
"ok": true,
"sorted": { "a": { "c": 3, "d": 2 }, "b": 1 },
"canonical": "{\"a\":{\"c\":3,\"d\":2},\"b\":1}",
"bytes": 25
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/keyword-extract
# Keyword Extractor
POST `/api/skills/keyword-extract` — $0.008 USDC on Base.
```json
{ "text": "Agents pay per call with USDC on Base using the x402 protocol.", "limit": 10 }
```
Stopword-filtered term ranking. Deterministic.
## Doc: https://grokzilla.shop/docs/llm-cost-quote
# LLM Cost Quote
Text or token counts in, cost per model out, cheapest first, from OpenRouter's public price list with a price-fetched-at timestamp. Applies time-of-day pricing. Not charged if the price list is unavailable or no model matches.
Price: **$0.0034** per call, USDC on Base (x402). Also available as the MCP tool `llm_cost_quote` at https://grokzilla.shop/mcp.
Text (token count approximated with our cl100k counter) or `input_tokens` in, cost per model out, cheapest first, from OpenRouter's public `/api/v1/models` price list (no key). `price_fetched_at` says when the prices were read (cached up to 10 minutes). Time-of-day and weekday prices OpenRouter publishes are applied for the current UTC time. Dynamic-price routers are excluded.
## Call
`POST /api/skills/llm-cost-quote`
```json
{"input_tokens": 3000, "output_tokens": 400, "models": ["openai/gpt-4o-mini", "google/gemini-2.5-flash"]}
```
- `text` (optional): string
- `input_tokens` (optional): integer
- `output_tokens` (optional, default `500`): integer
- `models` (optional): array
- `top` (optional, default `10`): integer
- `include_free` (optional, default `false`): boolean
- `request_id` (optional): Optional idempotency key. Echoed back; a credit-pack redemption with the same request_id and body is charged once.
## Not charged
Every non-200 has `charged: false` and is never settled.
- `422 invalid_params` / `400 invalid_params`: body fails the schema (checked before the 402).
- `400` before payment: neither or both of `text` and `input_tokens`, malformed model ids.
- `422 no_matching_models`: none of the requested models has a fixed price on OpenRouter.
- `503 price_list_unavailable`.
## Response (paid 200)
Same envelope on every data service: `ok, service, version, summary, data, confidence, sources, generated_at, data_as_of, charged, warnings, next`.
```json
{
"ok": true,
"skill": "llm_cost_quote",
"service": "llm_cost_quote",
"version": "1.0.0",
"summary": "cheapest: openai/gpt-4o-mini $0.00069 for 3000 in + 400 out tokens",
"data": {
"input_tokens": 3000,
"output_tokens": 400,
"token_source": "caller-supplied input_tokens",
"models_considered": 2,
"quotes": [
{
"model": "openai/gpt-4o-mini",
"name": "OpenAI: GPT-4o-mini",
"cost_usd": "0.00069",
"input_usd_per_mtok": "0.15",
"output_usd_per_mtok": "0.6",
"context_length": 128000,
"fits_context": true,
"time_based_price": false
},
{
"model": "google/gemini-2.5-flash",
"name": "Google: Gemini 2.5 Flash",
"cost_usd": "0.0019",
"input_usd_per_mtok": "0.3",
"output_usd_per_mtok": "2.5",
"context_length": 1048576,
"fits_context": true,
"time_based_price": false
}
],
"missing_models": [],
"price_fetched_at": "2026-10-17T11:12:57Z",
"currency": "USD"
},
"confidence": 0.97,
"sources": [
{
"name": "OpenRouter public models list",
"url": "https://openrouter.ai/api/v1/models",
"fetched_at": "2026-10-17T11:12:57Z"
}
],
"generated_at": "2026-10-17T11:12:57Z",
"data_as_of": "2026-10-17T11:12:57Z",
"charged": true,
"warnings": [],
"next": [
"token_count"
]
}
```
## Doc: https://grokzilla.shop/docs/news-brief
# News Brief with Sources
Topic in, deduplicated story clusters out: headline, every outlet URL and first-seen time, from GDELT and publisher RSS. Headlines and links only, no article text. Not charged when nothing matches or sources fail.
Price: **$0.0101** per call, USDC on Base (x402). Also available as the MCP tool `news_brief` at https://grokzilla.shop/mcp.
Topic in, deduplicated story clusters out. Sources: the GDELT 2.0 DOC API and a fixed list of publisher RSS feeds (BBC, NPR, The Guardian, Al Jazeera, France 24, Sky News, CBS, ABC, The New York Times, TechCrunch, Ars Technica, The Verge, Wired, Engadget, CoinDesk, Cointelegraph, Decrypt). **Headlines and links only**: no article text, description or image is republished. Open the outlet URL for the story.
Headlines are grouped when their words overlap (Jaccard ≥ 0.45). Clusters with more outlets come first. GDELT rate-limits shared IPs; when it does not answer, results come from RSS only and `warnings` says so.
## Call
`POST /api/skills/news-brief`
```json
{"topic": "bitcoin", "timespan": "3d", "max_clusters": 2}
```
- `topic` (required): string
- `timespan` (optional, default `"24h"`): string
- `max_clusters` (optional, default `10`): integer
- `request_id` (optional): Optional idempotency key. Echoed back; a credit-pack redemption with the same request_id and body is charged once.
## Not charged
Every non-200 has `charged: false` and is never settled.
- `422 invalid_params` / `400 invalid_params`: body fails the schema (checked before the 402).
- `400` before payment: topic shorter than 2 characters, only stopwords, or unsupported characters.
- `422 no_results`: nothing matched in the timespan.
- `503 sources_unavailable`: GDELT and every feed failed.
## Response (paid 200)
Same envelope on every data service: `ok, service, version, summary, data, confidence, sources, generated_at, data_as_of, charged, warnings, next`.
```json
{
"ok": true,
"skill": "news_brief",
"service": "news_brief",
"version": "1.0.0",
"summary": "2 stories on 'bitcoin'; top: Don’t Let a Crypto Inheritance Get Stuck on the Blockchain",
"data": {
"topic": "bitcoin",
"terms": [
"bitcoin"
],
"timespan": "3d",
"clusters": [
{
"headline": "Don’t Let a Crypto Inheritance Get Stuck on the Blockchain",
"first_seen": "2026-10-17T10:30:00Z",
"latest": "2026-10-17T10:30:00Z",
"outlet_count": 1,
"outlets": [
{
"outlet": "Wired",
"headline": "Don’t Let a Crypto Inheritance Get Stuck on the Blockchain",
"url": "https://www.wired.com/story/crypto-inheritance-how-to/",
"seen_at": "2026-10-17T10:30:00Z",
"via": "rss"
}
]
},
{
"headline": "‘Wow, it’s a real discovery’: Claude cracks a 25-year NSA number mystery",
"first_seen": "2026-10-17T06:39:48Z",
"latest": "2026-10-17T06:39:48Z",
"outlet_count": 1,
"outlets": [
{
"outlet": "CoinDesk",
"headline": "‘Wow, it’s a real discovery’: Claude cracks a 25-year NSA number mystery",
"url": "https://www.coindesk.com/tech/2026/10/17/wow-it-s-a-real-discovery-claude-cracks-a-25-year-nsa-number-mystery",
"seen_at": "2026-10-17T06:39:48Z",
"via": "rss"
}
]
}
],
"cluster_count": 2,
"headline_count": 2,
"searched": {
"gdelt": false,
"feeds_ok": 22,
"feeds_total": 22
}
},
"confidence": 0.7,
"sources": [
{
"name": "Wired",
"url": "https://www.wired.com/feed/rss",
"fetched_at": "2026-10-17T11:12:49Z"
},
{
"name": "CoinDesk",
"url": "https://www.coindesk.com/arc/outboundfeeds/rss/",
"fetched_at": "2026-10-17T11:12:49Z"
}
],
"generated_at": "2026-10-17T11:12:56Z",
"data_as_of": "2026-10-17T11:12:49Z",
"charged": true,
"warnings": [
"headlines and links only; open the outlet URL for the article",
"GDELT did not answer in time (it rate-limits shared IPs); results come from publisher RSS only"
],
"next": [
"url_to_markdown"
],
"note": "Headlines and links only. No article text is republished."
}
```
## Doc: https://grokzilla.shop/docs/osint-graph
# Public OSINT Graph
Resolves one public name on Wikidata and returns a relationship graph from a fixed property list (instance of, country, headquarters, founder, chief executive, ownership, employer, education, membership, and similar). Hops stop at 2. People include only notable public roles: employer, education, position, and membership. Family, addresses, and contact details are not returned. If nothing matches, `graph` is empty and `reason` says why. No confidence score is returned.
## Step 1 — Quick test
```bash
curl -s -X POST https://x402-micro-pay.com/api/skills/osint-graph \
-H "Content-Type: application/json" \
-d '{"seed_entity":"OpenAI","max_depth":2}'
```
## Step 2 — Agent client
```bash
python -m agent.humanless_client osint_graph --seed "OpenAI" --depth 2
```
## Input schema
| Field | Type | Required |
|-------|------|----------|
| seed_entity | string | yes |
| max_depth | integer (1–4 accepted; values above 2 run as 2) | no, default 2 |
An empty or missing seed is rejected (HTTP 400, or the request validator). The seed is not replaced with a sample.
## Output
`skill`, `seed_entity`, `max_depth`, `limit`, `disclaimer`, `resolved`, `alternatives` (up to three Wikidata candidates), `graph.nodes` (`id`, `name`, `type` (the Wikidata instance-of label), `kind` (`person`, `organization`, `place`, or `other`; `person` only when Wikidata says the node is a human, so a company is never typed as a person), `url`), `graph.edges` (`from`, `to`, `relation`, `pid`), `degrees_sample` (shortest paths that use those edges), and `sources`. `reason` is present when the seed did not match or a Wikidata call failed.
## Billing
Paid per call. The price is the `osint_graph` entry in `/api/catalog`.
## Doc: https://grokzilla.shop/docs/phone-normalize
# Phone Normalize & Validate
Parse and validate one phone number with full libphonenumber metadata: valid/possible, number type, region, E.164, national and international formats. Offline. No owner or carrier lookup. Unparseable numbers refused before payment.
Price: **$0.0021** per call, USDC on Base (x402). Also available as the MCP tool `phone_normalize` at https://grokzilla.shop/mcp.
Full libphonenumber metadata (python `phonenumbers`, Apache-2.0), offline. Returns valid/possible, number type, region, country code, E.164, national, international and RFC 3966 formats. **No owner, carrier or location lookup.**
## Call
`POST /api/skills/phone-normalize`
```json
{"number": "+1 415 555 2671"}
```
- `number` (required): string
- `region` (optional): ISO 3166-1 alpha-2 default region for numbers without +
- `request_id` (optional): Optional idempotency key. Echoed back; a credit-pack redemption with the same request_id and body is charged once.
## Not charged
Every non-200 has `charged: false` and is never settled.
- `422 invalid_params` / `400 invalid_params`: body fails the schema (checked before the 402).
- `400` before payment: not a number, a number without + and no `region`, unknown region, or impossible length.
## Response (paid 200)
Same envelope on every data service: `ok, service, version, summary, data, confidence, sources, generated_at, data_as_of, charged, warnings, next`.
```json
{
"ok": true,
"skill": "phone_normalize",
"service": "phone_normalize",
"version": "1.0.0",
"summary": "valid fixed_line_or_mobile number in US: +14155552671",
"data": {
"input": "+1 415 555 2671",
"valid": true,
"possible": true,
"type": "fixed_line_or_mobile",
"region": "US",
"country_code": 1,
"national_number": "4155552671",
"extension": null,
"e164": "+14155552671",
"international": "+1 415-555-2671",
"national": "(415) 555-2671",
"rfc3966": "tel:+1-415-555-2671",
"metadata": "libphonenumber 9.0.41"
},
"confidence": 1.0,
"sources": [],
"generated_at": "2026-10-17T11:12:57Z",
"data_as_of": "2026-10-17T11:12:57Z",
"charged": true,
"warnings": [],
"next": [
"email_check"
],
"note": "Format and validity only. No owner, carrier or location lookup."
}
```
## Doc: https://grokzilla.shop/docs/pii-redact
# PII Redactor
Replace personal data in free text with typed placeholders. Deterministic, regex-based, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/pii-redact`
```json
{ "text": "Mail jane@example.com or call 555-123-4567." }
```
`text` (required string, up to 400,000 characters).
| Type | Placeholder | Matches |
|---|---|---|
| email | `[EMAIL]` | `name@domain.tld` |
| ipv4 | `[IPV4]` | dotted quads with octets 0-255 |
| card | `[CARD]` | 13-19 digits (spaces or dashes allowed) that pass the Luhn check |
| ssn | `[SSN]` | SSN-shaped `123-45-6789` / `123 45 6789` |
| phone | `[PHONE]` | US formats like `(312) 555-0199`, `555.123.4567`, `+1 555 123 4567`, and `+`-prefixed international numbers (10-15 digits) |
This is pattern matching, not a guarantee: names and street addresses are not detected, and numbers that look like the shapes above are redacted.
## Response (paid 200)
```json
{
"skill": "pii_redact",
"ok": true,
"redacted": "Mail [EMAIL] or call [PHONE].",
"counts_by_type": {"email": 1, "ipv4": 0, "card": 0, "ssn": 0, "phone": 1},
"total": 2
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/seo
# SEO Optimizer
Fetches a public URL through the SSRF-safe client and returns an on-page SEO score
from real checks (title, meta description, headings, image alt text, keywords, and more).
If the page cannot be fetched, answers with an error status (403, 404, 5xx), serves a CDN/WAF challenge or block page (for example "Just a moment..."), or the call passes the 7 second cap, the route answers **422**: `score` is null, `reason` says why, `charged` is false, and no payment is settled. Invalid input (missing url, non-http(s) scheme, private or loopback host, keywords not a list) is refused with **400 before payment**, so no 402 is issued. A paid 200 always carries a real `score`, a letter `grade` (A ≥90, B ≥80, C ≥65, D ≥50, F <50), `top_fixes` (up to 3), and `charged: true`.
## Step 1 — curl
```bash
curl -s -X POST https://x402-micro-pay.com/api/skills/seo \
-H "Content-Type: application/json" \
-d '{"url":"https://example.com","keywords":["x402","agents"]}'
```
## Step 2 — Agent
```bash
python -m agent.humanless_client seo --url https://example.com
```
## Step 3 — Tutorial workflow
1. Run SEO on your landing page URL
2. Apply top recommendations (failed checks, highest weight first)
3. Re-run and compare `score`
## Doc: https://grokzilla.shop/docs/seo-v2
# SEO Optimizer v2
On-page SEO + AEO audit that hands you fixes, not just a score. Send a URL and get a 0-100 score across technical, content, metadata, structured data and AI-answer readiness, about 25 checks with severity and partial credit, and ready-to-paste fixes: title/meta, canonical, Open Graph/Twitter and a JSON-LD skeleton. Deterministic, no LLM, no API key (x402 USDC on Base). Scores reflect technical checks only. They don't predict or guarantee search rankings or AI citations.
## Call
`POST /api/skills/seo-v2` ($0.0997, 99700 atomic USDC)
```json
{"url": "https://www.python.org/", "keywords": ["python"]}
```
| Field | Type | Notes |
|---|---|---|
| `url` | string, required | public http(s) URL, at most 2000 characters |
| `keywords` | string[] | up to 20; adds a keyword-placement check |
| `include_fixes` | boolean | default true; false drops snippets and generated code |
| `locale` | string | BCP 47, default `en` |
| `previous_report_id` | string | `report_id` from an earlier run; adds `diff.fixed` / `diff.regressed` |
| `render_js` | boolean | not available yet; `true` is refused with 400 before payment |
`POST /api/skills/seo-compare` ($0.0503, 50300 atomic): `{"url", "competitor_urls": [1-3 URLs]}` runs v2 on each page and returns a per-check gap table.
Free: `GET /api/skills/seo-v2/sample` returns a full example report for a fixed demo page.
The original `POST /api/skills/seo` ($0.012) is unchanged.
## Errors (not charged)
`400` before payment: missing/invalid URL, private or loopback address, the marketplace's own hosts, `render_js: true`, a tampered `previous_report_id`.
**Blocked or unreachable pages are not charged.** Your payment is verified first and only settled after a real result (a non-null score; for seo-compare, a score for your own page). If the page blocks us or is unreachable, you get `422` with `score: null`, `status`, `reason` and `charged: false`, and the payment is never settled. If settlement fails after a good result, you get `402` and no result.
## Rubric (100 points, partial credit)
- Technical 25: HTTPS + no mixed content, status 200, not noindex (meta robots / X-Robots-Tag), one absolute self-canonical on the same host, viewport + lang, response time and HTML size.
- Content 20: one H1 matching the title, heading order, word count, image alt coverage, internal/external links plus a sample of up to 10 links checked for breakage.
- Metadata 20: title 30-60 characters, meta description 70-160, Open Graph title/description/image/url, twitter:card, hreflang validity.
- Structured data 15: JSON-LD parses, a recognized schema.org type, required properties per Google's type docs.
- AEO 15: text readable without JavaScript, answer-first intro (heuristic), Q&A or list structure, date/author/organization signals, keyword placement when keywords are given.
Severity: noindex, non-200 and canonical to another host are critical and cap the grade at D. Missing title/H1/description and invalid JSON-LD are high. Grades: A 90+, B 80+, C 65+, D 50+, F below 50.
Current practice (checked 2026-10-16): meta keywords and rel=next/prev are flagged as ignored by Google and never generated. FAQPage (rich result gone since May 7, 2026) and HowTo (gone since Sept 2023) are reported as valid schema.org with no Google rich result, never as a bonus.
## Doc: https://grokzilla.shop/docs/sha256
# SHA-256 Hash
Hash a string with SHA-256 and return hex plus a short prefix. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/sha256`
```json
{ "text": "hello", "encoding": "utf-8" }
```
`text` (required string), `encoding` (optional: `utf-8` default, `utf8`, `ascii`).
## Response (paid 200)
```json
{
"skill": "sha256",
"ok": true,
"algo": "sha256",
"bytes": 5,
"hex": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
"hex_prefix": "2cf24dba5fb0a30e"
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/slugify
# Slugify
Turn free text into a URL-safe lowercase slug. Deterministic, no network. First-party on grokzilla.shop.
## Call
`POST /api/skills/slugify`
```json
{ "text": "Hello, Grokzilla Shop!", "max_len": 80 }
```
`text` (required string), `max_len` (optional integer 1-200, default 80).
Accented letters fold to ASCII (`Café Déjà Vu` → `cafe-deja-vu`, `Straße` → `strasse`). Letters the fold does not cover are transliterated (`ß`→`ss`, `æ`→`ae`, `ø`→`o`, `ł`→`l`, `đ`→`d`). Text with no letters or digits returns an empty `slug`, `empty: true`, and a `reason`. That response is still `ok: true`.
## Response (paid 200)
```json
{
"skill": "slugify",
"ok": true,
"slug": "hello-grokzilla-shop",
"chars": 20,
"empty": false
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/text-diff
# Text Diff
Line / word / char diff with structured or unified output.
## Call
`POST /api/skills/text-diff`
```json
{
"a": "hello world",
"b": "hello grokzilla",
"options": { "mode": "words", "format": "structured" }
}
```
Unpaid → HTTP 402. Price: $0.01 per call.
## Doc: https://grokzilla.shop/docs/token-count
# Token Counter
POST `/api/skills/token-count` — $0.004 USDC on Base.
```json
{ "text": "Budget this prompt before the expensive hop.", "encoding": "cl100k" }
```
Approximate cl100k / o200k counts for spend decisions.
## Doc: https://grokzilla.shop/docs/token-price
# Verified Token Price (Base)
Verified USD price for a Base ERC-20: DeFiLlama cross-checked against the deepest on-chain Uniswap/Aerodrome pool. Returns price, spread, staleness, confidence. Refused, not charged, if sources disagree over 2.5% or one is missing. Data only, not investment advice.
Price: **$0.002** per call, USDC on Base (x402). Also available as the MCP tool `token_price` at https://grokzilla.shop/mcp.
Two independent free sources: the DeFiLlama coins API and the deepest on-chain Uniswap v2/v3 or Aerodrome (volatile) pool against WETH or USDC on Base, read at one pinned block over public keyless RPC. WETH legs are converted with the deepest on-chain WETH/USDC pool, so the on-chain number never uses DeFiLlama. No CoinGecko.
**Data only, not investment advice.** No buy/sell signal is given or implied.
## Call
`POST /api/skills/token-price`
```json
{"token": "0x4200000000000000000000000000000000000006"}
```
- `token` (required): Base ERC-20 contract address
- `chain` (optional, default `"base"`): string
- `request_id` (optional): Optional idempotency key. Echoed back; a credit-pack redemption with the same request_id and body is charged once.
## Not charged
Every non-200 has `charged: false` and is never settled.
- `422 invalid_params` / `400 invalid_params`: body fails the schema (checked before the 402).
- `422 sources_disagree`: the two sources differ by more than 2.5% (spread returned, no price).
- `422 insufficient_sources`: DeFiLlama has no fresh price (older than 1 hour), there is no pool, or the deepest pool holds under $10,000 on its quote side.
- `400` before payment: bad address, the zero/dead address, USDC itself (it is the quote asset), chain other than base.
## Response (paid 200)
Same envelope on every data service: `ok, service, version, summary, data, confidence, sources, generated_at, data_as_of, charged, warnings, next`.
```json
{
"ok": true,
"skill": "token_price",
"service": "token_price",
"version": "1.0.0",
"summary": "WETH $2433.056 (2 sources, spread 0.15%) - data only, not advice",
"data": {
"token": "0x4200000000000000000000000000000000000006",
"chain": "base",
"symbol": "WETH",
"decimals": 18,
"price_usd": "2433.056",
"spread_pct": 0.1524,
"agree": true,
"sources_agree_within_pct": 2.5,
"by_source": {
"defillama": {
"price_usd": "2434.91",
"confidence": 0.99,
"as_of": "2026-10-17T11:11:51Z",
"staleness_s": 58
},
"onchain": {
"price_usd": "2431.203",
"block": 52723111,
"pool": {
"dex": "uniswap_v3",
"variant": "fee 3000",
"address": "0x6c561b446416e1a00e8e93e221854d6ea4171372",
"quote": "USDC",
"quote_side_usd": 60045166.09
},
"weth_usd_onchain": 2431.202812620857
}
},
"disclaimer": "Data only, not investment advice. Spot prices from public sources at one point in time; they can be stale, manipulated in thin pools, or wrong. No buy/sell signal is given or implied."
},
"confidence": 0.975,
"sources": [
{
"name": "DeFiLlama coins API",
"url": "https://coins.llama.fi/prices/current/base:0x4200000000000000000000000000000000000006",
"fetched_at": "2026-10-17T11:12:48Z"
},
{
"name": "Base on-chain pool (public RPC)",
"url": "https://basescan.org/address/0x6c561b446416e1a00e8e93e221854d6ea4171372",
"fetched_at": "2026-10-17T11:12:48Z",
"block": 52723111
}
],
"generated_at": "2026-10-17T11:12:49Z",
"data_as_of": "2026-10-17T11:11:51Z",
"charged": true,
"warnings": [],
"next": [
"token_risk"
],
"disclaimer": "Data only, not investment advice. Spot prices from public sources at one point in time; they can be stale, manipulated in thin pools, or wrong. No buy/sell signal is given or implied."
}
```
## Doc: https://grokzilla.shop/docs/token-risk
# Token Risk (Base)
Heuristic risk checks for an ERC-20 token on Base mainnet before an agent buys or sells it: honeypot and transfer-tax simulation against the deepest pool, plus contract, metadata, proxy, owner and privileged-function checks. Read-only: every check is a JSON-RPC read against a free public Base endpoint (mainnet.base.org, then base-rpc.publicnode.com, then base.drpc.org). Nothing is signed or broadcast, and no paid data provider is called.
**Informational only, not financial advice.** The checks run at one block and can miss risks or flag legitimate tokens.
## Call
`POST /api/skills/token-risk`
```json
{"token": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "chain": "base"}
```
`token` (required): the token contract address (`0x` + 40 hex). `chain` (optional): only `"base"` for now.
## Checks
Each check is `{"result": "pass" | "warn" | "fail" | "unknown", "evidence": {...}}`. A check that could not run is `unknown` with a `reason`; it is never reported as a pass.
| Check | What it does | warn / fail when |
|---|---|---|
| `contract_code` | `eth_getCode` | fail: no code at the address |
| `erc20_metadata` | `name`, `symbol`, `decimals`, `totalSupply` | fail: none readable |
| `proxy` | EIP-1967 and legacy zeppelinos implementation/admin slots | warn: upgradeable proxy |
| `ownership` | `owner()` / `getOwner()` | warn: owner still set; pass: `0x0` or `0x…dEaD` |
| `privileged_functions` | PUSH4 selectors in the token's (and implementation's) bytecode: mint, blacklist, pause, fee setters, trading switches / limits | warn: any found (presence only, not who may call them) |
| `liquidity_pool` | Uniswap v2 `getPair`, Uniswap v3 `getPool` (fees 100/500/3000/10000), Aerodrome `getPool` (volatile/stable) against WETH and USDC; the pool holding the most of the token is used | warn: thin quote-side liquidity |
| `sell_simulation` | `eth_simulateV1`: a holder (balance planted with a state override after locating the balance storage slot) transfers 0.1% of the pool's balance into the pool, the token-side leg of a sell | fail: reverts, returns false, or delivers nothing |
| `buy_simulation` | the same amount transferred out of the pool, the token-side leg of a buy | same as above |
| `transfer_tax` | `1 − received / sent` for both legs, from `balanceOf` before and after | warn ≥ 1%, fail > 10% |
A Uniswap quoter is not used for tax: it quotes the pool's math, not what a fee-on-transfer token actually delivers, so the token transfer is measured directly. AMM fees are not included.
`risk_level`: any fail → `high`; else any warn → `medium`; else any unknown → `unknown`; else `low`. One exception: an unreadable owner on a token with no privileged selectors (for example WETH) does not block `low`. `reasons` lists what drove the level.
## Errors (not charged)
- `422 invalid_params`: missing or malformed `token`, `chain` other than `"base"`.
- `400 invalid_token`: zero or dead address.
- `502 upstream_error`: no public Base RPC answered.
## Response (paid 200, USDC)
USDC is `medium` because it is an upgradeable proxy with an active owner and mint, blacklist and pause functions. Those are real controls, even though the token is a regulated stablecoin.
```json
{
"skill": "token_risk",
"ok": true,
"token": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
"chain": "base",
"chain_id": 8453,
"block": 52494540,
"symbol": "USDC",
"risk_level": "medium",
"reasons": [
"proxy: warn",
"ownership: warn",
"privileged_functions: warn"
],
"checks": {
"contract_code": {
"result": "pass",
"evidence": {
"bytecode_bytes": 1852,
"block": 52494540
}
},
"erc20_metadata": {
"result": "pass",
"evidence": {
"name": "USD Coin",
"symbol": "USDC",
"decimals": 6,
"total_supply": "4419304031200909",
"missing": []
}
},
"proxy": {
"result": "warn",
"evidence": {
"standard": "zeppelinos (legacy unstructured storage)",
"implementation": "0x2ce6311ddae708829bc0784c967b7d77d19fd779",
"admin": "0x4fc7850364958d97b4d3f5a08f79db2493f8ca44",
"note": "upgradeable: whoever controls the proxy can replace the token's code"
}
},
"ownership": {
"result": "warn",
"evidence": {
"function": "owner()",
"owner": "0x3abd6f64a422225e61e435bae41db12096106df7",
"renounced": false
}
},
"privileged_functions": {
"result": "warn",
"evidence": {
"found": {
"mint": [
"configureMinter(address,uint256)",
"mint(address,uint256)"
],
"blacklist": [
"blacklist(address)",
"isBlacklisted(address)"
],
"pause": [
"pause()",
"unpause()"
]
},
"scanned": [
"token",
"implementation"
],
"note": "selector presence only; who may call them is not checked"
}
},
"liquidity_pool": {
"result": "pass",
"evidence": {
"dex": "uniswap_v3",
"variant": "fee 3000",
"pool": "0x6c561b446416e1a00e8e93e221854d6ea4171372",
"quote_token": "WETH",
"token_balance": "76072526114911",
"quote_balance": "29060996929756341666149",
"thin_liquidity": false,
"pools_found": 7
}
},
"sell_simulation": {
"result": "pass",
"evidence": {
"pool": "0x6c561b446416e1a00e8e93e221854d6ea4171372",
"amount": "76072526114",
"balance_slot": "solidity:9",
"method": "eth_simulateV1 transfer leg",
"received": "76072526114"
}
},
"buy_simulation": {
"result": "pass",
"evidence": {
"pool": "0x6c561b446416e1a00e8e93e221854d6ea4171372",
"amount": "76072526114",
"balance_slot": "solidity:9",
"method": "eth_simulateV1 transfer leg",
"received": "76072526114"
}
},
"transfer_tax": {
"result": "pass",
"evidence": {
"sell_tax_pct": 0.0,
"buy_tax_pct": 0.0,
"note": "token-side transfer tax only; AMM/pool fees are not included"
}
}
},
"rpc": "mainnet.base.org",
"disclaimer": "Informational only, not financial advice. These are automated heuristics from public on-chain reads and simulations at a single block. They can miss risks (owner actions after this block, time-, amount- or wallet-specific traps, off-chain controls, other pools) and can flag legitimate tokens (for example regulated stablecoins with blacklist and pause functions). Do your own research."
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.005 per call.
## Doc: https://grokzilla.shop/docs/url-normalize
# URL Normalizer
Strip tracking params, force HTTPS, lowercase host, sort query, extract components.
## Call
`POST /api/skills/url-normalize`
```json
{
"url": "http://Example.COM/path?utm_source=x&b=2&a=1",
"options": { "stripTracking": true, "forceHttps": true, "sortQuery": true }
}
```
Unpaid → HTTP 402. Price: $0.01 per call.
## Doc: https://grokzilla.shop/docs/url-to-markdown
# URL to Markdown
Fetch one public web page and get back its title and clean Markdown: headings, paragraphs, links (made absolute), emphasis, lists, code blocks, blockquotes, images and basic tables. Built for agents that need to read a page after a search. First-party on grokzilla.shop; no third-party API is involved.
## Call
`POST /api/skills/url-to-markdown`
```json
{"url": "https://example.com"}
```
`url` (required): an absolute `http://` or `https://` URL, at most 2,000 characters.
## How the page is fetched
- User agent: `Mozilla/5.0 (compatible; grokzilla-url-to-markdown/1.0; +https://grokzilla.shop/terms)`.
- **robots.txt is honored** for `grokzilla-url-to-markdown` (a `User-agent: grokzilla` group also matches). It is read once per host per call, including for every host a redirect leads to. Per RFC 9309, a 4xx robots.txt means no restrictions; a 5xx or unreachable one means the site is treated as disallowing crawlers.
- **SSRF guard** (shared with seo and ai-detector): only http/https; every hostname is resolved and the connection pinned to a vetted public IP; private, loopback, link-local and cloud-metadata addresses are refused, on the first request and after every redirect.
- At most 3 redirects, 5 seconds and 1 MB per page. Larger pages are cut at 1 MB and Markdown at 200,000 characters; `truncated` is then `true`.
- Only `text/html` and `application/xhtml+xml` are converted. JavaScript is not run, so client-rendered pages may come back thin.
- grokzilla.shop, grokzilla.info and x402-micro-pay.com are refused before payment (400, no 402).
## Errors (not charged)
- `422 invalid_params`: missing `url`, not a string, no `http(s)://` scheme, over 2,000 characters.
- `400`: `unsupported_url` (our own domains), `blocked_url` (private / metadata address), `invalid_url`, `robots_disallowed`, `robots_unreachable`, `unsupported_content_type`, `http_error` (the page returned non-2xx), `too_many_redirects`, `redirect_loop`.
- `502 upstream_error`: timeout or connection failure.
## Response (paid 200)
```json
{
"skill": "url_to_markdown",
"ok": true,
"url": "https://example.com",
"final_url": "https://example.com/",
"title": "Example Domain",
"markdown": "This domain is for use in documentation examples without needing permission. This is not a service; avoid relying on it for testing and monitoring purposes.",
"bytes": 577,
"truncated": false
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/uuid-mint
# UUID Minter
Mint 1-32 UUID v4 (or v1) identifiers for agent job IDs and idempotency keys. First-party on grokzilla.shop.
## Call
`POST /api/skills/uuid-mint`
```json
{ "count": 2, "version": 4 }
```
`count` (optional integer 1-32, default 1), `version` (optional `4` default, or `1`).
## Response (paid 200)
IDs below are placeholders showing the shape; each paid call mints fresh random IDs.
```json
{
"skill": "uuid_mint",
"ok": true,
"version": 4,
"count": 2,
"ids": [
"00000000-0000-4000-8000-000000000001",
"00000000-0000-4000-8000-000000000002"
]
}
```
Unpaid → HTTP 402 (x402 USDC on Base). Retry with `PAYMENT-SIGNATURE`. Free preflight: send `X-X402-Validate-Only: 1` (422 on bad params, else 402).
Price: $0.003 per call.
## Doc: https://grokzilla.shop/docs/mcp/agent-pays-in-30-seconds
# Your agent pays for a tool call in 30 seconds
Checked live on Oct 17, 2026. The script in step 3 ran exactly as written with @x402/mcp 2.28.0 and a funded wallet at 11:57 AM CT and settled on Base ([tx `0xfee8d931…9dfcd0`](https://basescan.org/tx/0xfee8d9319effe4eac28e91d3f3c484aed22356846b0db0ea2d758882999dfcd0)).
## What you need
- A wallet on Base with a little USDC. One call costs between $0.002 and $0.012 (prices in ). You don't need ETH for gas: you sign a USDC authorization and the facilitator submits it.
- Node 18 or later.
## 1. Add the server
Streamable HTTP, no auth, no API key:
```json
{
"mcpServers": {
"grokzilla-micro-pay": {
"url": "https://grokzilla.shop/mcp"
}
}
}
```
Any MCP client can list the tools and call the two free ones, `list_skills` and `get_skill`. A paid tool returns a payment challenge until your client can pay. That's step 3.
## 2. Look before you pay (free)
Ask your client for `tools/list`. Each paid tool's description ends with its price, for example `json_repair`: "Price $0.0041 via x402."
## 3. Make one paid call
```bash
npm i @x402/mcp @x402/evm @modelcontextprotocol/sdk viem
```
```ts
// pay.mjs: run with PRIVATE_KEY=0x... node pay.mjs
import { createx402MCPClient } from "@x402/mcp";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { privateKeyToAccount } from "viem/accounts";
const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const PAY_TO = "0xc22f9caebac37fe72d5142f35f21f6696ea9ef69";
const client = createx402MCPClient({
name: "my-agent",
version: "1.0.0",
schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(account) }],
// Pay only our address, only USDC on Base, at most 2 cents a call.
policies: [(_v, reqs) => reqs.filter(r =>
r.network === "eip155:8453" &&
r.payTo.toLowerCase() === PAY_TO &&
BigInt(r.amount) <= 20_000n)],
onPaymentRequested: ({ toolName, paymentRequired }) => {
console.log(`${toolName}: paying ${paymentRequired.accepts[0].amount} atomic USDC`);
return true;
},
});
await client.connect(new StreamableHTTPClientTransport(new URL("https://grokzilla.shop/mcp")));
const result = await client.callTool("json_repair", { text: "{a: 1, b: [2,3,],}" });
console.log(result.content[0].text);
console.log("tx:", result.paymentResponse?.transaction);
```
## What you get back
The actual output of the run above:
```
json_repair: paying 4100 atomic USDC
{"skill": "json_repair", "ok": true, "json": {"a": 1, "b": [2, 3]}, "repaired": "{\"a\":1,\"b\":[2,3]}", "fixes": ["unquoted_keys", "trailing_commas"], "changed": true}
tx: 0xfee8d9319effe4eac28e91d3f3c484aed22356846b0db0ea2d758882999dfcd0
```
What happened:
The first call gets a challenge for 4100 atomic USDC ($0.0041) to `0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69` on `eip155:8453`. The client signs it and retries for you. Then you get the repaired JSON. The example in the challenge, for a messier input, looks like this:
```json
{"skill":"json_repair","ok":true,"json":{"name":"Ada","tags":["math","code"],"active":true},
"repaired":"{\"name\":\"Ada\",\"tags\":[\"math\",\"code\"],\"active\":true}",
"fixes":["unquoted_keys","single_quotes","trailing_commas","python_literals","removed_comments"],"changed":true}
```
`result.paymentResponse` holds `success`, `payer`, `transaction` and `network`. `transaction` is the Base transaction hash, so you can check the payment on-chain.
If the call fails, you get `isError: true`. Only count it as paid if `result.paymentResponse?.transaction` is set: the client also reports `paymentMade: true` when it signed but nothing settled. Bad arguments and a payment that can't be verified both come back this way, unsettled.
For production, also check `scheme` and `asset` as shown in [spend limits](/docs/mcp/spend-limits).
More: [paid call, step by step](/docs/mcp/mcp-paid-call-example) · [spend limits](/docs/mcp/spend-limits) · [MCP quickstart](/agents)
## Doc: https://grokzilla.shop/docs/mcp/mcp-paid-call-example
# A paid MCP tool call, step by step
Every request and response here was captured from the live server on Oct 17, 2026, including a real paid call at 11:57 AM CT ([tx `0x8922d5ca…0412b2`](https://basescan.org/tx/0x8922d5ca49e0267f7462cc747e57ea4bd085afd91cd50e01e135b0ed520412b2) on Base).
Server: `https://grokzilla.shop/mcp`, Streamable HTTP, stateless JSON-RPC. No API key and no session header.
## 1. initialize
```bash
curl -sS https://grokzilla.shop/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"0.0.1"}}}'
```
Reply (trimmed):
```json
{"jsonrpc":"2.0","id":1,"result":{
"protocolVersion":"2025-06-18",
"capabilities":{"tools":{"listChanged":false}},
"serverInfo":{"name":"grokzilla-micro-pay","version":"0.1.0"},
"instructions":"Tools are pay-per-call over x402 (USDC on Base, eip155:8453). Discovery tools list_skills and get_skill are free. ..."}}
```
Then send `{"jsonrpc":"2.0","method":"notifications/initialized"}`. The server answers HTTP 202 with no body.
## 2. tools/list
```bash
curl -sS https://grokzilla.shop/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
```
You get 30 tools. `list_skills` and `get_skill` are free. The other 28 are paid, one per skill, and each description ends with its price, for example "Price $0.0041 via x402." Here is the `json_repair` entry:
```json
{"name":"json_repair",
"description":"Repair malformed or truncated JSON from LLMs, JS or Python: ... Price $0.0041 via x402.",
"inputSchema":{"type":"object","properties":{"text":{"type":"string","minLength":1,"maxLength":400000}},"required":["text"]}}
```
## 3. tools/call without payment: the challenge
```bash
curl -sS https://grokzilla.shop/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"json_repair","arguments":{"text":"{a: 1, b: [2,3,],}"}}}'
```
The HTTP status is 200, because the challenge rides inside the MCP result, not as an HTTP 402. The skill does not run. Captured reply (the long description and bazaar schema are cut down):
```json
{"jsonrpc":"2.0","id":3,"result":{
"isError": true,
"content":[{"type":"text","text":"Payment required. Amount 4100 (atomic USDC) on eip155:8453 via scheme exact, payTo 0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69. This tool is pay-per-call via x402 (USDC on Base). The skill handler did not run. structuredContent is the PaymentRequired challenge."}],
"structuredContent":{
"x402Version": 2,
"error": "Payment required to access this tool",
"resource": {
"url": "mcp://tool/json_repair",
"description": "Repair malformed or truncated JSON ...",
"mimeType": "application/json",
"serviceName": "Grokzilla x402 Micro Pay"
},
"accepts": [{
"scheme": "exact",
"network": "eip155:8453",
"asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
"amount": "4100",
"payTo": "0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69",
"maxTimeoutSeconds": 300,
"extra": {"name": "USD Coin", "version": "2"}
}],
"extensions": {"bazaar": {
"info": {
"input": {"type":"mcp","toolName":"json_repair","transport":"streamable-http","inputSchema":{"...":"same as tools/list"},"example":{"text":"```json\n{name: 'Ada', tags: ['math', 'code',], active: True, // note\n}\n```"}},
"output": {"type":"json","example":{"skill":"json_repair","ok":true,"json":{"name":"Ada","tags":["math","code"],"active":true},"repaired":"{\"name\":\"Ada\",\"tags\":[\"math\",\"code\"],\"active\":true}","fixes":["unquoted_keys","single_quotes","trailing_commas","python_literals","removed_comments"],"changed":true}}
},
"schema": {"...": "JSON Schema for info"}
}}
}}}
```
How to read it:
- `amount` is in USDC's smallest unit (6 decimals). `4100` is $0.0041, the same as the catalog price.
- `asset` is native USDC on Base. `extra.name` and `extra.version` are the EIP-712 domain your wallet signs against.
- `payTo` is where the money goes. Check it before you sign (see [spend limits](/docs/mcp/spend-limits)).
- `maxTimeoutSeconds: 300` is how long the signed authorization stays valid.
## 4. Pay and retry
You don't build the payment by hand. An x402-aware MCP client reads `structuredContent`, signs an exact USDC authorization (EIP-3009) with your wallet, and repeats the same `tools/call` with the payment in `params._meta["x402/payment"]`:
```json
{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{
"name":"json_repair",
"arguments":{"text":"{a: 1, b: [2,3,],}"},
"_meta":{"x402/payment": { "...": "PaymentPayload signed by your client" }}}}
```
The server checks the payment with its facilitator, runs the same handler as the HTTP route, settles, and returns the result. Captured paid reply (Oct 17, 11:57 AM CT; that capture used JSON-RPC id 2):
```json
{"jsonrpc":"2.0","id":2,"result":{
"content":[{"type":"text","text":"{\"skill\": \"json_repair\", \"ok\": true, ...}"}],
"structuredContent":{"skill":"json_repair","ok":true,"json":{"a":1,"b":[2,3]},"repaired":"{\"a\":1,\"b\":[2,3]}","fixes":["unquoted_keys","trailing_commas"],"changed":true},
"isError": false,
"_meta":{"x402/payment-response":{
"success": true,
"payer": "0x708755c5f9ec60aB416D956e1ED3c15775372B52",
"transaction": "0x8922d5ca49e0267f7462cc747e57ea4bd085afd91cd50e01e135b0ed520412b2",
"network": "eip155:8453"}}}}
```
`transaction` is the Base transaction hash. That one moved 4100 atomic USDC from the payer to `0xc22f…Ef69`.
If the payment can't be verified (an unfunded wallet, for example), nothing settles and the skill doesn't run. You get `isError: true` with the challenge back in `structuredContent` (`"error": "payment_verification_failed"`) and this `_meta`:
```json
{"x402/error":{"code":"payment_verification_failed","reason":"payment_verification_failed","message":"The facilitator could not verify this payment."},"charged":false}
```
Clients that do this today: TypeScript `@x402/mcp` (`createx402MCPClient`) and Python `x402.mcp`. See [your agent pays in 30 seconds](/docs/mcp/agent-pays-in-30-seconds) for a working setup.
## When nothing is charged
- Bad input on tools that check before asking for payment (seo, url_to_markdown, and the six data tools token_price, email_check, news_brief, ip_intel, llm_cost_quote, phone_normalize): you get an error result with `"charged": false` and no challenge at all. Captured example, `seo` with `{}`:
`{"ok":false,"error":"invalid_url","detail":"url is required. No payment was taken.","charged":false,"status":400}`
- Bad arguments on the other tools (json_repair included): the challenge still comes back, but if you pay, the call returns `isError: true` with the field error (`"Invalid arguments: body: 'text' is a required property"`) and the payment is not settled. Tested Oct 17 with a real signed payment: no USDC moved. Check arguments against `inputSchema` first anyway.
- A failed payment verification (see above) is not settled and says `"charged": false`.
- Results with nothing real to give (seo with no score, for example) are returned as errors and, per our server rules, not settled. That case wasn't part of the Oct 17 paid test.
## Same call over plain HTTP
Each tool is also `POST https://grokzilla.shop/api/skills/` (the skill name with dashes, for example `json-repair`). Unpaid, that returns a real HTTP 402 with the same `accepts[]` in the body and base64 in the `payment-required` header. Add `X-X402-Validate-Only: 1` to check your input for free: 422 if it's wrong, 402 if it's ready to pay.
## Doc: https://grokzilla.shop/docs/mcp/spend-limits
# Capping what your agent spends
Checked against the live server on Oct 17, 2026, including real paid calls at 11:55–11:57 AM CT.
Every paid call on grokzilla.shop is one small, exact USDC payment on Base. Nothing is billed afterwards and there's no account to top up. You only pay for calls you sign. These rules keep that safe.
## 1. Check every challenge before you sign
Pay only if all of these match:
| Field in `accepts[0]` | Must be |
|---|---|
| `scheme` | `exact` |
| `network` | `eip155:8453` (Base mainnet) |
| `asset` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` (USDC) |
| `payTo` | `0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69` |
| `amount` | the catalog price × 1,000,000, nothing higher |
The same payTo is published at (`pay_to`). If a challenge names any other address, don't pay, and tell us.
Prices are in (`price_usd`) and at the end of each MCP tool description. As of Oct 17 the per-call MCP tools run from $0.002 (token_price) to $0.012 (seo). Over plain HTTP, a few site-audit skills cost more, up to $0.1993 per call. Always read the live catalog rather than this page.
Our published limits are in (`constraints`): at most $0.25 per call and $0.50 per session. Every per-call skill fits under that cap. Items listed in `one_time_purchases` (such as the $1 credit pack and downloadable kits) are explicit purchases outside that cap, so buy them only on purpose.
## 2. Set a per-call cap
`@x402/mcp` already refuses any single payment over $1 by default (`spendControls.maxAmountPerPayment`). That's far above anything here, so tighten it. A policy that only accepts our exact terms and caps each call at 2 cents:
```ts
const PAY_TO = "0xc22f9CAEBAc37fE72D5142f35f21f6696Ea9Ef69".toLowerCase();
const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913".toLowerCase();
const MAX_PER_CALL = 20_000n; // $0.02 in USDC atomic units
const onlyGrokzilla = (_v: number, reqs: any[]) =>
reqs.filter(r =>
r.scheme === "exact" &&
r.network === "eip155:8453" &&
String(r.asset).toLowerCase() === USDC_BASE &&
String(r.payTo).toLowerCase() === PAY_TO &&
BigInt(r.amount) <= MAX_PER_CALL);
```
Pass it as `policies: [onlyGrokzilla]` to `createx402MCPClient`. If nothing passes the filter, the client doesn't pay.
## 3. Set a daily budget
The client has no built-in daily total, so keep one yourself in `onPaymentRequested`. Return `false` to refuse:
```ts
let spentToday = 0n; // reset at midnight in your own scheduler
const DAILY_BUDGET = 500_000n; // $0.50, the same as max_spend_per_session_usd
onPaymentRequested: async ({ toolName, paymentRequired }) => {
const amount = BigInt(paymentRequired.accepts[0].amount);
if (spentToday + amount > DAILY_BUDGET) return false;
spentToday += amount; // counts approvals, so it may over-count failed calls
return true;
}
```
Count conservatively. Note that `@x402/mcp` returns `paymentMade: true` whenever it signed and retried, even if the server rejected the payment and nothing settled (seen live Oct 17, both with an unfunded key and with a paid call that had bad arguments). If you want an exact ledger, record the `transaction` from `_meta["x402/payment-response"]` and only count calls that carry one.
Simplest hard limit of all: fund the paying wallet with only what you're willing to spend.
## 4. When you're not charged
- **Bad input, before payment.** Over HTTP, add `X-X402-Validate-Only: 1` to any skill request. Wrong input gets 422 with field errors and no challenge; good input gets the 402. Checked live on json-repair, sha256, slugify, json-flatten, token-count and url-to-markdown. Some skills (seo, url-to-markdown with a private URL, and the six data skills) refuse bad input with 400 and `"charged": false` even without that header, over HTTP and MCP.
- **Bad input, after you paid.** Most tools (json_repair, sha256 and the other simple utilities) return the challenge even when the arguments are wrong. If you sign anyway, the payment is not settled. Tested Oct 17 with real signed payments on json_repair `{}`: over HTTP it returned 422 `invalid_params`; over MCP, `isError: true` with "Invalid arguments: ...". No USDC moved either time. Validate against `inputSchema` first to save the round trip.
- **Payment can't be verified.** Over MCP you get `isError: true` and `_meta` `{"x402/error":{"code":"payment_verification_failed",...},"charged":false}`. Nothing settles.
- **Nothing chargeable, after payment.** If a skill runs but has nothing real to give you (seo with no score, for example), the server answers 422 or another 4xx/5xx with `"charged": false` and doesn't settle. This follows our server rules; the Oct 17 paid test didn't cover it.
## 5. Retries and double charges
- A payment is one signed USDC authorization with its own nonce. It can settle once at most, so resending the same signed payment can't charge you twice.
- On a timeout or a network error after you sent a payment, check the wallet's USDC history for a transfer to the payTo before signing a new one. If it went through, don't pay again for the same call.
- An unsettled authorization expires after `maxTimeoutSeconds` (300 seconds here). After that it can't be used.
- `isError: true` with no `x402/payment-response` in `_meta` means nothing settled. Fix the issue and pay fresh.
- There's no `Idempotency-Key` support for x402 calls on this server, so don't rely on one.
## 6. Keep the key away from the server
The server never asks for a key and never holds one. Your client signs locally. Never paste a private key into a tool argument.