Grok-ready website intelligence in one line

Step one

Add the server

Register the endpoint as a Remote MCP tool in the xAI SDK. Grok performs discovery itself — it calls tools/list, reads the strict input schemas, and decides when to invoke. Nothing else is required to get the tools in front of the model.

Copy snippet

from xai_sdk.tools import mcp

tools = [
    mcp(
        server_url="https://api.santosautomation.com/mcp",
        server_label="santos",
    )
]

The server_labelis how the tools are namespaced in the model’s context; santos keeps traces readable. Verify the same list the model sees, from your own shell:

curl -X POST https://api.santosautomation.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Step two

Ask Grok to use it

Nothing else to configure. Paste this into Grok with the server registered — it audits this very page, so you can check the answer against what is in front of you.

Copy prompt

audit https://www.santosautomation.com/integrations/grok with the Santos tools.

Grok picks audit_website_preview on its own — a free tool, so no wallet is involved — and returns scores across the four dimensions, the individual pass/fail checks, and prioritized fixes. If that comes back, your wiring is correct and everything else on this page is a variation on it.

Step three

What Grok sees

Seven tools. The three free previews execute and return a full result inline. The four paid tools validate the target and return the canonical x402 HTTP request — they never move funds themselves.

All prices are USDC on Base mainnet (eip155:8453). The three free previews share one quota: one call per day per identity.

That identity matters when Grok is the caller. Without a token the quota is keyed on the calling IP — and a hosted agent reaches this server from xAI infrastructure, so a single daily call is shared by every Grok user at once. Pass a token and the quota moves onto that individual user instead. Every free tool accepts one:

# once per user — 6-digit code by email, token valid 30 days
curl -X POST https://api.santosautomation.com/api/leads/verify/request \
  -H 'Content-Type: application/json' \
  -d '{"email":"you@example.com","url":"https://example.com"}'

curl -X POST https://api.santosautomation.com/api/leads/verify/confirm \
  -H 'Content-Type: application/json' \
  -d '{"email":"you@example.com","code":"123456"}'

# then pass it as a tool argument
{"name":"audit_website_preview","arguments":{"url":"https://example.com","token":"<token>"}}

An invalid token is rejected outright rather than silently falling back to the shared IP allowance. For anything beyond evaluation, pay per call — there is no quota on the paid endpoints.

Step four

The handoff pattern

This is the part worth understanding. A paid MCP tool does not settle payment. It validates the target, then returns the exact HTTP request to pay for — method, URL, price, network, and protocol. Your agent, or a thin wrapper around it, performs the settlement. Santos never holds a key of yours and never signs on your behalf.

The tool result comes back on MCP’s error channel — isError: true with one text block. That is deliberate: a payment-required result is not a finished answer, and signalling it as an error keeps the model from reporting a price quote as though it were an audit. The text names the price, the exact URL to pay for, and the free preview:

{
  "isError": true,
  "content": [
    {
      "type": "text",
      "text": "PAYMENT_REQUIRED: Agent Readiness costs $0.075 USDC per successful
               audit on Base mainnet via x402 v2. Request
               https://api.santosautomation.com/api/agent-readiness?url=https%3A%2F%2Fexample.com%2F&depth=quick
               without a signature to receive PAYMENT-REQUIRED terms, then sign and
               retry with PAYMENT-SIGNATURE. Free preview: GET
               https://api.santosautomation.com/api/agent-readiness/demo?url=https%3A%2F%2Fexample.com%2F
               (1/day per IP, shared quota, same result shape)."
    }
  ]
}

Settling it is a single wrapped fetch against that URL. Any x402 v2 client works; the payment step is identical to the one in the CI recipe.

Copy settlement

// Any x402 v2 client settles the URL named in the handoff text.
import { privateKeyToAccount } from "viem/accounts";
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";

const fetchWithPay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{
    network: "eip155:8453",
    client: new ExactEvmScheme(privateKeyToAccount(process.env.X402_PRIVATE_KEY)),
  }],
});

// Build the same URL the handoff names — the 402, signing, and retry are automatic.
const target = "https://example.com";
const res = await fetchWithPay(
  `https://api.santosautomation.com/api/agent-readiness?url=${encodeURIComponent(target)}&depth=quick`
);
const report = await res.json();
console.log(report.website_intelligence_score);

Rationale

Why this works

Contracts

Machine surfaces

Everything Grok needs to reason about this service is public and versioned. Current release and live status are always machine-readable.