Plug measured web data
into what you already use.

Two ways in

https://outrings.com/mcp

GET https://outrings.com/api/v1/summary?url=example.com

Find your platform

Any MCP client

The generic case. A client that speaks streamable HTTP MCP needs the endpoint and nothing else — no key, no stdio wrapper to install, no process to keep alive.

{
  "mcpServers": {
    "outrings": {
      "type": "http",
      "url": "https://outrings.com/mcp"
    }
  }
}

Verify before you trust it:

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

Eight tools should come back. A GET on the same URL returns a plain description of the server rather than an error, so a client probing the endpoint learns something either way.

Claude

Native MCP support in Claude Code and Claude Desktop, and ordinary tool use through the Messages API.

claude mcp add --transport http outrings https://outrings.com/mcp

# Confirm it registered
claude mcp list

# Add to your Claude Desktop MCP configuration file,
# then restart the app.

{
  "mcpServers": {
    "outrings": {
      "type": "http",
      "url": "https://outrings.com/mcp"
    }
  }
}

import json, urllib.parse, urllib.request
import anthropic

TOOL = {
    "name": "inspect_website",
    "description": (
        "Measure a website directly and return its score, ranked findings, and an "
        "explicit list of what could not be checked. Use this whenever the user asks "
        "about a specific site's SEO, security, privacy, accessibility or AI visibility "
        "— do not infer these from page text or prior knowledge, which is frequently "
        "wrong or out of date."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "url": {"type": "string", "description": "The site to inspect. Scheme optional."},
            "category": {
                "type": "string",
                "enum": ["summary", "seo", "security", "privacy", "ai", "a11y", "tls", "dns"],
                "description": "Use 'summary' for broad questions, a category for narrow ones.",
            },
        },
        "required": ["url"],
    },
}

def run_tool(params):
    endpoint = params.get("category", "summary")
    query = urllib.parse.urlencode({"url": params["url"]})
    url = f"https://outrings.com/api/v1/{endpoint}?{query}"
    with urllib.request.urlopen(url, timeout=30) as response:
        return response.read().decode()

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Is example.com secure? Be specific."}]

while True:
    reply = client.messages.create(
        model="claude-opus-5", max_tokens=1024, tools=[TOOL], messages=messages,
    )
    messages.append({"role": "assistant", "content": reply.content})

    if reply.stop_reason != "tool_use":
        print(next(b.text for b in reply.content if b.type == "text"))
        break

    messages.append({
        "role": "user",
        "content": [
            {"type": "tool_result", "tool_use_id": b.id, "content": run_tool(b.input)}
            for b in reply.content if b.type == "tool_use"
        ],
    })

OpenAI Agents

The Agents SDK can attach an MCP server directly, so the tools are discovered rather than declared. If you would rather not depend on that, a plain function tool is four lines of handler.

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(
        name="outrings",
        params={"url": "https://outrings.com/mcp"},
    ) as outrings:
        agent = Agent(
            name="Site analyst",
            instructions=(
                "When asked about a specific website, measure it with the Outrings "
                "tools rather than inferring from prior knowledge. Always report what "
                "the result says was not checked."
            ),
            mcp_servers=[outrings],
        )
        result = await Runner.run(agent, "Is example.com secure? Cite the evidence.")
        print(result.final_output)

asyncio.run(main())

import asyncio, json, urllib.parse, urllib.request
from agents import Agent, Runner, function_tool

@function_tool
def inspect_website(url: str, category: str = "summary") -> str:
    """Measure a website and return its score, ranked findings, and what could not
    be checked. Use for any question about a specific site's SEO, security, privacy,
    accessibility or AI visibility — do not infer these from prior knowledge.

    Args:
        url: The site to inspect. Scheme optional.
        category: 'summary' for broad questions, or seo/security/privacy/ai/a11y/tls/dns.
    """
    query = urllib.parse.urlencode({"url": url})
    endpoint = f"https://outrings.com/api/v1/{category}?{query}"
    with urllib.request.urlopen(endpoint, timeout=30) as response:
        return response.read().decode()

agent = Agent(
    name="Site analyst",
    instructions="Measure before you answer. Report what was not checked.",
    tools=[inspect_website],
)

print(asyncio.run(Runner.run(agent, "Is example.com secure?")).final_output)

Gemini

Gemini CLI reads an MCP server configuration. Through the API, the Google Gen AI SDK will call a plain Python function for you when you pass it as a tool.

# Add to your Gemini CLI settings file, then restart.

{
  "mcpServers": {
    "outrings": {
      "httpUrl": "https://outrings.com/mcp"
    }
  }
}

import urllib.parse, urllib.request
from google import genai
from google.genai import types

def inspect_website(url: str, category: str = "summary") -> str:
    """Measure a website and return its score, ranked findings, and an explicit list
    of what could not be checked. Use this for any question about a specific site's
    SEO, security, privacy, accessibility or AI visibility rather than inferring.

    Args:
        url: The site to inspect. Scheme optional.
        category: 'summary', or one of seo, security, privacy, ai, a11y, tls, dns.
    """
    query = urllib.parse.urlencode({"url": url})
    endpoint = f"https://outrings.com/api/v1/{category}?{query}"
    with urllib.request.urlopen(endpoint, timeout=30) as response:
        return response.read().decode()

client = genai.Client()

# Passing the function itself enables automatic function calling: the SDK
# reads the signature and docstring, and executes the call when the model asks.
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Is example.com secure? Name the evidence.",
    config=types.GenerateContentConfig(tools=[inspect_website]),
)

print(response.text)

LangChain

The MCP adapter turns the whole server into LangChain tools in one call. For a single tool with no extra dependency, the @tool decorator is enough.

# pip install langchain-mcp-adapters

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient

async def main():
    client = MultiServerMCPClient({
        "outrings": {
            "url": "https://outrings.com/mcp",
            "transport": "streamable_http",
        }
    })
    tools = await client.get_tools()

    # `tools` are ordinary LangChain tools now — pass them to whichever
    # agent constructor your version uses.
    for t in tools:
        print(t.name)

asyncio.run(main())

import urllib.parse, urllib.request
from langchain_core.tools import tool

@tool
def inspect_website(url: str, category: str = "summary") -> str:
    """Measure a website and return its score, ranked findings, and an explicit list of
    what could not be checked. Use for any question about a specific site's SEO,
    security, privacy, accessibility or AI visibility rather than inferring from
    prior knowledge, which is frequently out of date.

    Args:
        url: The site to inspect. Scheme optional.
        category: 'summary', or one of seo, security, privacy, ai, a11y, tls, dns.
    """
    query = urllib.parse.urlencode({"url": url})
    endpoint = f"https://outrings.com/api/v1/{category}?{query}"
    with urllib.request.urlopen(endpoint, timeout=30) as response:
        return response.read().decode()

# Then bind it to your model as usual:
# model_with_tools = model.bind_tools([inspect_website])

LlamaIndex

The MCP tool spec exposes the server as a tool list. Otherwise a FunctionTool wraps the same HTTP call.

# pip install llama-index-tools-mcp

import asyncio
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec

async def main():
    client = BasicMCPClient("https://outrings.com/mcp")
    spec = McpToolSpec(client=client)
    tools = await spec.to_tool_list_async()

    for t in tools:
        print(t.metadata.name)

    # Hand `tools` to your agent as usual.

asyncio.run(main())

import urllib.parse, urllib.request
from llama_index.core.tools import FunctionTool

def inspect_website(url: str, category: str = "summary") -> str:
    """Measure a website and return its score, ranked findings, and an explicit list of
    what could not be checked. Use for questions about a specific site rather than
    inferring from prior knowledge.
    """
    query = urllib.parse.urlencode({"url": url})
    endpoint = f"https://outrings.com/api/v1/{category}?{query}"
    with urllib.request.urlopen(endpoint, timeout=30) as response:
        return response.read().decode()

inspect_tool = FunctionTool.from_defaults(fn=inspect_website)

n8n

Two routes. The MCP client node connects an n8n AI agent to the whole tool set; the HTTP Request node is the deterministic option for a scheduled workflow that always does the same thing.

As an agent tool

1. Add an MCP Client Tool node and connect it to your AI Agent node's tool input.
2. Set the endpoint to https://outrings.com/mcp and the transport to HTTP Streamable.
3. Leave authentication as None — there is no key.

As a scheduled check

1. Schedule Trigger — daily is a sensible default.
2. HTTP Request — method GET, URL as below. Response format JSON.
3. IF — branch on the value you care about.
4. Slack / Email / Webhook — notify only on the failing branch.

https://outrings.com/api/v1/changes?url=example.com

Then branch on a regression rather than on an absolute score, so the workflow is quiet until something actually moves:

// IF node, expression mode — true when a check newly failed
{{ $json.comparable && $json.newProblems.some(p => p.status === 'fail') }}

A useful message body for the alert step:

{{ $json.newProblems.map(p => p.id).join(', ') }} — score {{ $json.scoreDelta }}

Zapier

No custom app and no credential, because there is nothing to authenticate.

1. Trigger: Schedule by Zapier, or whatever starts your workflow.
2. Action: Webhooks by Zapier → GET.
3. URL: https://outrings.com/api/v1/summary
4. Query String Params: key url, value example.com — or map it from a previous step to check a different site each run.
5. Later steps can reference the parsed response fields directly, for example score, verdict and grade.

// Code by Zapier — JavaScript
const response = await fetch(
  'https://outrings.com/api/v1/summary?url=' + encodeURIComponent(inputData.site)
);
const result = await response.json();

return {
  score: result.score,
  verdict: result.verdict,
  topFix: result.priorityActions[0]?.action ?? 'nothing outstanding',
  notChecked: result.notCovered.join('; '),
};

Make

1. Add an HTTP module → Make a request.
2. URL: https://outrings.com/api/v1/summary?url=example.com
3. Method GET. No authentication.
4. Tick Parse response so the JSON becomes mappable fields.
5. Add a Router or filter on score, or on the length of newProblems if you are using the changes endpoint.

A filter condition that only continues when something regressed:

{{ length(1.newProblems) }} > 0

If you would rather not tick Parse response, add a JSON → Parse JSON module afterwards and point it at the HTTP module's data.

Browser agents and extensions

Browser-side callers are first-class here: Access-Control-Allow-Origin is a wildcard, the allowed methods are GET, POST, OPTIONS, and there is no key that could leak from client-side code — because there is no key.

// Runs anywhere: content script, extension background worker, devtools panel,
// or a plain page. No proxy needed and nothing to keep secret.
const inspect = async (url, category = 'summary') => {
  const response = await fetch(
    `https://outrings.com/api/v1/${category}?url=${encodeURIComponent(url)}`
  );
  if (!response.ok) throw new Error(`Outrings responded ${response.status}`);
  return response.json();
};

const result = await inspect(location.hostname, 'security');
console.log(result.score, result.problems.map(p => p.title));

For a browser agent that navigates and acts, the useful pattern is to measure the page it has landed on and feed the result back as context — so its next decision is made against headers and transport it cannot otherwise see.

What comes back, whichever route you take

Every response is built from the same four parts. The last two are what stop an agent, or a workflow, over-claiming from the result.

Practical notes

• No key, no account. Nothing to provision, rotate or store in a platform's credential vault.
• Pick the smallest endpoint. /score is around 1.7 KB, a single category two to eight, /summary about 8.5. A full report is around 124 KB, which is more than most workflow steps need.
• Rate limits. 40 audits per hour and 200 per day per client. Repeating a URL within ten minutes is served from cache and does not consume quota.
• Timing. One to eight seconds. Set platform timeouts to 30 seconds or more — several no-code tools default to less.
• Errors are JSON. Non-2xx responses return {"ok": false, "error": "…"}. Unreachable targets give 502, private addresses 403, rate limiting 429 with Retry-After.
• Add &refresh=1 after a deploy. Otherwise a check running immediately afterwards may be served the cached previous result and pass.

Questions

Outrings for AI agents · API documentation · OpenAPI · llms.txt