{ try it }

{
  "seed_entity": "OpenAI",
  "max_depth": 2
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "seed_entity": {
      "type": "string"
    },
    "max_depth": {
      "type": "integer"
    },
    "limit": {
      "type": "integer"
    },
    "disclaimer": {
      "type": "string"
    },
    "resolved": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "url": {
          "type": "string"
        }
      }
    },
    "alternatives": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "url": {
            "type": "string"
          }
        }
      }
    },
    "graph": {
      "type": "object",
      "properties": {
        "nodes": {
          "type": "array",
          "items": {
            "type": "object"
          }
        },
        "edges": {
          "type": "array",
          "items": {
            "type": "object"
          }
        },
        "max_depth": {
          "type": "integer"
        }
      }
    },
    "degrees_sample": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "depth": {
            "type": "integer"
          },
          "path": {
            "type": "array"
          }
        }
      }
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "skill"
  ]
}

{
  "skill": "osint_graph",
  "seed_entity": "OpenAI",
  "max_depth": 2,
  "limit": 25,
  "disclaimer": "Public data only. Not a substitute for licensed people search. Comply with privacy laws and platform ToS.",
  "resolved": {
    "id": "Q21708200",
    "name": "OpenAI",
    "description": "American artificial intelligence research organization",
    "url": "https://www.wikidata.org/wiki/Q21708200"
  },
  "alternatives": [
    {
      "id": "Q21708200",
      "name": "OpenAI",
      "description": "American artificial intelligence research organization",
      "url": "https://www.wikidata.org/wiki/Q21708200"
    }
  ],
  "graph": {
    "nodes": [
      {
        "id": "Q21708200",
        "name": "OpenAI",
        "type": "enterprise",
        "url": "https://www.wikidata.org/wiki/Q21708200"
      },
      {
        "id": "Q111759432",
        "name": "Reddit Inc.",
        "type": "dot-com company",
        "url": "https://www.wikidata.org/wiki/Q111759432"
      },
      {
        "id": "Q62",
        "name": "San Francisco",
        "type": "city in the United States",
        "url": "https://www.wikidata.org/wiki/Q62"
      },
      {
        "id": "Q7407093",
        "name": "Sam Altman",
        "type": "human",
        "url": "https://www.wikidata.org/wiki/Q7407093"
      }
    ],
    "edges": [
      {
        "from": "Q21708200",
        "to": "Q7407093",
        "relation": "founder",
        "pid": "P112"
      },
      {
        "from": "Q21708200",
        "to": "Q62",
        "relation": "headquarters location",
        "pid": "P159"
      },
      {
        "from": "Q7407093",
        "to": "Q111759432",
        "relation": "employer",
        "pid": "P108"
      }
    ],
    "max_depth": 2
  },
  "degrees_sample": [
    {
      "depth": 1,
      "path": [
        "OpenAI",
        "San Francisco"
      ]
    },
    {
      "depth": 1,
      "path": [
        "OpenAI",
        "Sam Altman"
      ]
    },
    {
      "depth": 2,
      "path": [
        "OpenAI",
        "Sam Altman",
        "Reddit Inc."
      ]
    }
  ],
  "sources": [
    "https://www.wikidata.org/w/api.php",
    "https://query.wikidata.org/sparql"
  ]
}

1. POST https://grokzilla.shop/api/skills/osint-graph with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "10000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.01 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "query": "What is x402?"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "query": {
      "type": "string"
    },
    "answer": {
      "type": "string"
    },
    "key_points": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "n": {
            "type": "integer"
          },
          "title": {
            "type": "string"
          },
          "url": {
            "type": "string"
          },
          "snippet": {
            "type": "string"
          }
        }
      }
    },
    "method": {
      "type": "string"
    },
    "fetched_at": {
      "type": "string"
    }
  },
  "required": [
    "skill"
  ]
}

{
  "skill": "research",
  "query": "What is x402?",
  "answer": "x402 is built-in to existing HTTP requests, with no additional communication required. [1]\nx402 enables agents to monetize their own services, pay other agents, or handle micropayments automatically on behalf of users. [2]",
  "key_points": [
    "x402 is built-in to existing HTTP requests, with no additional communication required. [1]",
    "x402 enables agents to monetize their own services, pay other agents, or handle micropayments automatically on behalf of users. [2]"
  ],
  "sources": [
    {
      "n": 1,
      "title": "x402",
      "url": "https://x402.org/",
      "snippet": "An open protocol for internet-native payments."
    },
    {
      "n": 2,
      "title": "Google Agentic Payments Protocol + x402",
      "url": "https://www.coinbase.com/developer-platform/discover/launches/google_x402",
      "snippet": "Agents can pay each other with stablecoins over the x402 open protocol."
    }
  ],
  "method": "extractive",
  "fetched_at": "2026-10-05T06:00:00Z"
}

1. POST https://grokzilla.shop/api/skills/research with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "15000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.015 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "url": "https://example.com"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "url": {
      "type": "string"
    },
    "final_url": {
      "type": "string"
    },
    "score": {
      "type": "integer"
    },
    "recommendations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "keywords": {
      "type": "array"
    },
    "stats": {
      "type": "object",
      "properties": {
        "status_code": {
          "type": "integer"
        },
        "word_count": {
          "type": "integer"
        }
      }
    }
  },
  "required": [
    "skill"
  ]
}

{
  "skill": "seo",
  "url": "https://example.com",
  "final_url": "https://example.com/",
  "score": 28,
  "recommendations": [
    "Add exactly one H1 heading.",
    "Lengthen the title to 30-60 characters (currently 14).",
    "Add a meta description of 70 to 160 characters."
  ],
  "keywords": [],
  "stats": {
    "status_code": 200,
    "word_count": 25
  }
}

1. POST https://grokzilla.shop/api/skills/seo with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "12000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.012 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "text": "So I finally fixed the porch light on Saturday. It's worth noting that I'd tried twice before and gave up (the wiring is ancient). Honestly the whole thing was a testament to stubbornness. My brother Sam held the ladder and complained the entire time, which didn't help one bit. In conclusion, the bulb works, the switch clicks, and I only shocked myself once! Next up is the doorbell, if I can find the manual. I can't, probably. It's in a box somewhere in the garage behind 3 bikes and a broken lawnmower."
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "verdict": {
      "type": "string"
    },
    "classifier": {
      "type": "object",
      "properties": {
        "verdict": {
          "type": "string"
        },
        "probability_ai": {
          "type": "number"
        },
        "threshold_ai": {
          "type": "number"
        },
        "threshold_human": {
          "type": "number"
        },
        "model_version": {
          "type": "string"
        },
        "model_kind": {
          "type": "string"
        }
      }
    },
    "content_type": {
      "type": "string"
    },
    "possible_ai_influence": {
      "type": "boolean"
    },
    "rubric_score": {
      "type": "number"
    },
    "sections": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "section": {
            "type": "string"
          },
          "section_weight": {
            "type": "number"
          },
          "result": {
            "type": "string"
          },
          "evidence": {
            "type": "array"
          }
        }
      }
    },
    "tell_phrases": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "phrase": {
            "type": "string"
          },
          "tell_weight": {
            "type": "number"
          },
          "count": {
            "type": "integer"
          }
        }
      }
    },
    "ai_likelihood": {
      "type": "number"
    },
    "band": {
      "type": "array",
      "items": {
        "type": "number"
      }
    },
    "signals": {
      "type": "object",
      "properties": {
        "sentence_length_mean": {
          "type": "number"
        },
        "sentence_length_variance": {
          "type": "number"
        },
        "burstiness": {
          "type": "number"
        },
        "type_token_ratio": {
          "type": "number"
        },
        "hapax_ratio": {
          "type": "number"
        },
        "punctuation_diversity": {
          "type": "integer"
        },
        "repeated_ngram_rate": {
          "type": "number"
        },
        "stock_phrase_per_100": {
          "type": "number"
        },
        "stock_phrase_hits": {
          "type": "integer"
        },
        "stock_phrases_found": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "contraction_rate": {
          "type": "number"
        },
        "average_word_length": {
          "type": "number"
        },
        "line_length_uniformity": {
          "type": "null"
        },
        "line_count": {
          "type": "integer"
        },
        "verse_like": {
          "type": "boolean"
        },
        "sentence_count": {
          "type": "integer"
        },
        "lexical_features_used": {
          "type": "boolean"
        }
      }
    },
    "method": {
      "type": "string"
    },
    "word_count": {
      "type": "integer"
    },
    "caveats": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "skill"
  ]
}

{
  "skill": "ai_detector",
  "verdict": "possible_ai_influence",
  "classifier": {
    "verdict": "uncertain",
    "probability_ai": 0.362,
    "threshold_ai": 0.585,
    "threshold_human": 0.3233,
    "model_version": "2026-10-13",
    "model_kind": "logistic_regression"
  },
  "content_type": "opinion",
  "possible_ai_influence": true,
  "rubric_score": 0.4,
  "sections": [
    {
      "section": "rhythm",
      "section_weight": 0.1,
      "result": "no_signal",
      "evidence": [
        "8 sentences, sentence-length CV 0.35 (AI <= 0.34, human >= 0.55)",
        "rhythm is in the overlap range where human and prompted-AI text both sit"
      ]
    },
    {
      "section": "vocabulary",
      "section_weight": 0.4,
      "result": "ai_sign",
      "evidence": [
        "tell-phrase weight 2.4 (2.64 per 100 words, 138-entry list)",
        "tells: it's worth noting, a testament to, in conclusion",
        "lexical diversity MTLD 105 (informational, not scored)",
        "surprisal mean 3.21, variance 2.15, spike 0.40; rare-word share 0.033; MATTR 0.834; Zipf slope deviation 0.63",
        "tell phrases are dense; possible AI influence (secondary signal)"
      ]
    },
    {
      "section": "voice_structure",
      "section_weight": 0.3,
      "result": "no_signal",
      "evidence": [
        "ai cues: hedging (2 hedges)",
        "human cues: none",
        "first person, names, dialogue and sensory detail are not counted either way"
      ]
    },
    {
      "section": "resolution",
      "section_weight": 0.2,
      "result": "no_signal",
      "evidence": [
        "rhythm vs vocabulary: no_overlap (no_signal / ai_sign)",
        "vocabulary vs voice_structure: no_overlap (ai_sign / no_signal)",
        "voice_structure vs rhythm: no_overlap (no_signal / no_signal)",
        "tell phrases present but not confirmed by two sections; secondary signal only"
      ]
    }
  ],
  "tell_phrases": [
    {
      "phrase": "it's worth noting",
      "tell_weight": 0.9,
      "count": 1
    },
    {
      "phrase": "a testament to",
      "tell_weight": 0.9,
      "count": 1
    },
    {
      "phrase": "in conclusion",
      "tell_weight": 0.6,
      "count": 1
    }
  ],
  "ai_likelihood": 0.7822,
  "band": [
    0.5334,
    1.0
  ],
  "signals": {
    "sentence_length_mean": 11.375,
    "sentence_length_variance": 16.2344,
    "burstiness": 0.3542,
    "type_token_ratio": 0.7582,
    "hapax_ratio": 0.8841,
    "punctuation_diversity": 4,
    "repeated_ngram_rate": 0.0,
    "stock_phrase_per_100": 3.2967,
    "stock_phrase_hits": 3,
    "stock_phrases_found": [
      "it's worth noting",
      "a testament to",
      "in conclusion"
    ],
    "contraction_rate": 3.2967,
    "average_word_length": 4.3846,
    "line_length_uniformity": null,
    "line_count": 1,
    "verse_like": false,
    "sentence_count": 8,
    "lexical_features_used": true
  },
  "method": "stylometry",
  "word_count": 91,
  "caveats": [
    "Detection is probabilistic and should not be used as the only evidence that a text was or was not written by a person.",
    "ai_likelihood is a stylometric score from 0 to 1, not a calibrated probability. The band widens when there is less text and is not a statistical confidence interval.",
    "A low score means these surface patterns are weak. It does not prove a person wrote the text.",
    "Weights were chosen on a small set of public-domain prose, poems, and synthetic assistant-style paragraphs. Fixture accuracy is not a field accuracy."
  ]
}

1. POST https://grokzilla.shop/api/skills/ai-detector with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "10000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.01 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "data": {
    "a": {
      "b": 1
    }
  }
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "flat": {
      "type": "object",
      "properties": {
        "a.b": {
          "type": "integer"
        }
      }
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "json_flatten",
  "ok": true,
  "flat": {
    "a.b": 1
  }
}

1. POST https://grokzilla.shop/api/skills/json-flatten with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "6000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.006 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "data": {
    "b": 1,
    "a": {
      "d": 2,
      "c": 3
    }
  },
  "reverse": false
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "sorted": {
      "type": "object",
      "properties": {
        "a": {
          "type": "object",
          "properties": {
            "c": {
              "type": "integer"
            },
            "d": {
              "type": "integer"
            }
          }
        },
        "b": {
          "type": "integer"
        }
      }
    },
    "canonical": {
      "type": "string"
    },
    "bytes": {
      "type": "integer"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "json_sort",
  "ok": true,
  "sorted": {
    "a": {
      "c": 3,
      "d": 2
    },
    "b": 1
  },
  "canonical": "{\"a\":{\"c\":3,\"d\":2},\"b\":1}",
  "bytes": 25
}

1. POST https://grokzilla.shop/api/skills/json-sort with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "a": "hello",
  "b": "hallo"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "mode": {
      "type": "string"
    },
    "ops": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "op": {
            "type": "string"
          },
          "value": {
            "type": "string"
          }
        }
      }
    },
    "inserted": {
      "type": "integer"
    },
    "deleted": {
      "type": "integer"
    },
    "equal": {
      "type": "integer"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "text_diff",
  "ok": true,
  "mode": "lines",
  "ops": [
    {
      "op": "del",
      "value": "hello"
    },
    {
      "op": "ins",
      "value": "hallo"
    }
  ],
  "inserted": 1,
  "deleted": 1,
  "equal": 0
}

1. POST https://grokzilla.shop/api/skills/text-diff with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "6000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.006 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "url": "http://example.com/?utm_source=x"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "canonical": {
      "type": "string"
    },
    "scheme": {
      "type": "string"
    },
    "host": {
      "type": "string"
    },
    "path": {
      "type": "string"
    },
    "query": {
      "type": "object"
    },
    "stripped_tracking": {
      "type": "boolean"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "url_normalize",
  "ok": true,
  "canonical": "https://example.com/",
  "scheme": "https",
  "host": "example.com",
  "path": "/",
  "query": {},
  "stripped_tracking": true
}

1. POST https://grokzilla.shop/api/skills/url-normalize with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "5000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.005 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "html": "<p>hi</p>",
  "mode": "text"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "mode": {
      "type": "string"
    },
    "chars": {
      "type": "integer"
    },
    "output": {
      "type": "string"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "html_clean",
  "ok": true,
  "mode": "text",
  "chars": 2,
  "output": "hi"
}

1. POST https://grokzilla.shop/api/skills/html-clean with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "8000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.008 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "instance": {
    "n": 1
  },
  "schema": {
    "type": "object",
    "required": [
      "n"
    ]
  }
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "valid": {
      "type": "boolean"
    },
    "errors": {
      "type": "array"
    },
    "checked": {
      "type": "boolean"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "json_schema_validate",
  "ok": true,
  "valid": true,
  "errors": [],
  "checked": true
}

1. POST https://grokzilla.shop/api/skills/json-schema-validate with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "6000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.006 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "text": "x402 micropay on Base USDC",
  "limit": 5
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "keywords": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "term": {
            "type": "string"
          },
          "count": {
            "type": "integer"
          }
        }
      }
    },
    "unique_terms": {
      "type": "integer"
    },
    "tokens": {
      "type": "integer"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "keyword_extract",
  "ok": true,
  "keywords": [
    {
      "term": "x402",
      "count": 1
    },
    {
      "term": "micropay",
      "count": 1
    },
    {
      "term": "base",
      "count": 1
    },
    {
      "term": "usdc",
      "count": 1
    }
  ],
  "unique_terms": 4,
  "tokens": 4
}

1. POST https://grokzilla.shop/api/skills/keyword-extract with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "8000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.008 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "count": 2,
  "version": 4
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "version": {
      "type": "integer"
    },
    "count": {
      "type": "integer"
    },
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "uuid_mint",
  "ok": true,
  "version": 4,
  "count": 2,
  "ids": [
    "00000000-0000-4000-8000-000000000001",
    "00000000-0000-4000-8000-000000000002"
  ]
}

1. POST https://grokzilla.shop/api/skills/uuid-mint with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "text": "Hello, Grokzilla Shop!",
  "max_len": 80
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "slug": {
      "type": "string"
    },
    "chars": {
      "type": "integer"
    },
    "empty": {
      "type": "boolean"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "slugify",
  "ok": true,
  "slug": "hello-grokzilla-shop",
  "chars": 20,
  "empty": false
}

1. POST https://grokzilla.shop/api/skills/slugify with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "text": "Mail [email protected] or call 555-123-4567."
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "redacted": {
      "type": "string"
    },
    "counts_by_type": {
      "type": "object",
      "properties": {
        "email": {
          "type": "integer"
        },
        "ipv4": {
          "type": "integer"
        },
        "card": {
          "type": "integer"
        },
        "ssn": {
          "type": "integer"
        },
        "phone": {
          "type": "integer"
        }
      }
    },
    "total": {
      "type": "integer"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "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
}

1. POST https://grokzilla.shop/api/skills/pii-redact with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "csv": "First Name,E-mail\nAda,[email protected]\n",
  "delimiter": ","
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "headers": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "rows": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "first_name": {
            "type": "string"
          },
          "e_mail": {
            "type": "string"
          }
        }
      }
    },
    "row_count": {
      "type": "integer"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "csv_normalize",
  "ok": true,
  "headers": [
    "first_name",
    "e_mail"
  ],
  "rows": [
    {
      "first_name": "Ada",
      "e_mail": "[email protected]"
    }
  ],
  "row_count": 1
}

1. POST https://grokzilla.shop/api/skills/csv-normalize with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "mode": "encode",
  "text": "hello agent",
  "url_safe": false
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "mode": {
      "type": "string"
    },
    "url_safe": {
      "type": "boolean"
    },
    "output": {
      "type": "string"
    },
    "bytes": {
      "type": "integer"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "skill": "base64",
  "ok": true,
  "mode": "encode",
  "url_safe": false,
  "output": "aGVsbG8gYWdlbnQ=",
  "bytes": 11
}

1. POST https://grokzilla.shop/api/skills/base64 with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "value": 1700000000,
  "tz": "America/Chicago"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "input_kind": {
      "type": "string"
    },
    "epoch_s": {
      "type": "integer"
    },
    "epoch_ms": {
      "type": "integer"
    },
    "iso_utc": {
      "type": "string"
    },
    "iso_tz": {
      "type": "string"
    },
    "tz": {
      "type": "string"
    },
    "utc_offset": {
      "type": "string"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "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"
}

1. POST https://grokzilla.shop/api/skills/epoch-convert with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "url": "https://example.com"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "url": {
      "type": "string"
    },
    "final_url": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "markdown": {
      "type": "string"
    },
    "bytes": {
      "type": "integer"
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "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
}

1. POST https://grokzilla.shop/api/skills/url-to-markdown with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "3000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.003 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)

{
  "token": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "chain": "base"
}

{
  "type": "object",
  "properties": {
    "skill": {
      "type": "string"
    },
    "ok": {
      "type": "boolean"
    },
    "token": {
      "type": "string"
    },
    "chain": {
      "type": "string"
    },
    "chain_id": {
      "type": "integer"
    },
    "block": {
      "type": "integer"
    },
    "symbol": {
      "type": "string"
    },
    "risk_level": {
      "type": "string"
    },
    "reasons": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "checks": {
      "type": "object",
      "properties": {
        "contract_code": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "erc20_metadata": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "proxy": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "ownership": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "privileged_functions": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "liquidity_pool": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "sell_simulation": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "buy_simulation": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        },
        "transfer_tax": {
          "type": "object",
          "properties": {
            "result": {
              "type": "string"
            },
            "evidence": {
              "type": "object"
            }
          }
        }
      }
    },
    "rpc": {
      "type": "string"
    },
    "disclaimer": {
      "type": "string"
    }
  },
  "required": [
    "ok",
    "skill"
  ]
}

{
  "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."
}

1. POST https://grokzilla.shop/api/skills/token-risk with the JSON body, no payment header
2. ← 402 Payment Required + PAYMENT-REQUIRED header: base64 JSON {x402Version: 2, accepts: [{scheme: "exact", network: "eip155:8453", asset: USDC, amount: "5000", payTo}]} (same JSON in the body)
3. your x402 client checks amount ≤ $0.005 and signs a USDC transfer authorization to payTo with your wallet
4. retry the same POST with PAYMENT-SIGNATURE: <base64> (x402 v2) or X-PAYMENT (v1 clients)
5. ← 200 OK with the result JSON + PAYMENT-RESPONSE header (base64 settlement receipt, tx hash on Base)