Do I need an API key to connect an agent?

No. The MCP server and the REST API are both keyless and require no account. Every tool is read-only and annotated as such, so an agent can call them without a confirmation step.

How does the agent know when to use the tool?

Each tool description says when measuring beats inferring from page text, and which cheaper tool to prefer when the question is narrow. The descriptions are written for the model, not for a documentation page.

Can the agent over-claim from a result?

Every result carries a notCovered array naming what was not checked and an undetermined bucket for checks that reached no verdict. Nothing that could not be determined is folded in with the passes, so an agent has the material it needs to qualify its answer.

Which MCP transport does it use?

Streamable HTTP. Every call is a self-contained JSON-RPC 2.0 POST; the server opens no SSE streams, which is what shared hosting can honestly guarantee.

Model Context Protocol

Give your agent
a way to check.

An assistant asked about a website will answer from page text, training data and plausibility. Connect Outrings and it can go and measure instead — then show what it measured.

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

No key. No account. Read-only. Eight tools arrive with descriptions telling the model when to reach for them.

The difference, on one question

A user asks their assistant whether a site is secure. Both answers below are plausible. Only one of them is checkable.

Without a measurement tool

Is example.com secure?

Most modern sites use HTTPS and standard security headers. example.com is a well-established domain, so it likely has TLS configured correctly and follows common security practices. You may want to verify with a scanner.

Fluent, unfalsifiable, and derived from nothing. The model has not looked at the site — it cannot, so it describes what sites like it usually do.

With Outrings connected

Is example.com secure?

calls check_category { "url": "example.com", "category": "security" }

Security scores 68/100. Three findings: no Content-Security-Policy header; X-Frame-Options absent, so the page can be framed; and the server banner discloses nginx/1.18.0. HSTS is present with max-age=31536000. Not checked: known-vulnerability databases and anything requiring JavaScript to run.

Every clause traces to a response header the tool actually read, and the answer states its own boundary rather than implying completeness.

What comes back

Every tool result is built from the same four parts. The last two are the ones that keep an agent honest.

Findings

What is wrong, ranked by points recovered per unit of effort — computed from the same weights that produced the score, so the projected gain is arithmetic rather than an opinion.

Evidence

The raw observation each verdict came from: the header value, the certificate field, the robots.txt line. An agent can quote the reason, not just the conclusion.

Coverage

A notCovered array naming what this service does not measure at all, so an absent finding is never mistaken for a clean result.

Undetermined

Checks that reached no verdict, kept in their own bucket with a reason — blocked, timeout, requires_browser. Never folded in with the passes.

The tools

Read-only, annotated readOnlyHint: true, so a client can call them without asking the user to approve each one. Full argument schemas are in the API documentation.

Tool	The question it answers
get_score	"How good is this site?" — the cheapest call, numbers only.
check_category	"Is my site secure?" · "Why is my SEO bad?" — one area, with findings and fixes.
audit_website	"What is wrong with my website?" — everything, ranked.
check_ai_visibility	"Why does no assistant ever mention my site?" — per crawler, naming the rule responsible.
what_changed	"Did my last deploy break anything?" — deltas against the previous snapshot.
compare_websites	"How do we compare to them?" — up to four sites, with the category gaps.
get_site_inventory	"What does this page actually load?" — links, scripts, forms, endpoints, emails.
get_badge_embed	"Can I show this publicly?" — embeddable markup for a live measured score.

Connecting other clients

Any client that speaks streamable HTTP MCP can point at the same endpoint. There is no stdio wrapper to install and no process to keep alive.

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

Check it by hand first

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

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 useful either way.

Not using MCP?

The same measurements are one HTTP request away, with no key and open CORS — so a browser extension, a serverless function and a backend job are all equally able to call it.

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

See the API documentation for the full endpoint list, response shaping and client examples in Python, JavaScript and TypeScript.

Where this fits

Assistant platforms

Users ask about their own sites constantly. Answering from measurement rather than plausibility is the difference between a useful answer and a confident one.

Agentic workflows

A deploy agent can call what_changed and refuse to ship when security or accessibility regressed, using the same numbers a human would review.

Developer tooling

Reproducible output means results can be diffed and asserted against. The same observations under the same ruleset produce the same result.

Research and monitoring

Structured, comparable observations across many domains, with provenance attached to each one, and public aggregate statistics for context.

Limits, stated plainly. Outrings does not run JavaScript, so anything a browser would render client-side is reported as requires_browser rather than guessed at. It does not consult CVE databases, WHOIS, or ranking and backlink data. It measures what an HTTP client and a DNS resolver can observe, and says so. Every check is documented.

Questions

Do I need an API key?

No — neither for MCP nor for REST. There is no account, no trial and no rate-limited tier to graduate from. Requests are throttled per address to keep the service available, and the limit is well above what an assistant answering a user's question will reach.

How does the model know when to call it?

Each tool description is written for the model rather than for a documentation page: it says which questions warrant measuring instead of inferring, and points at the cheaper tool when the question is narrow. audit_website, for instance, explicitly directs the model to check_category when only one area matters.

How long does a call take?

get_score and a single category are typically two to four seconds. A full audit is two to eight, depending on how quickly the target responds and whether a deep crawl is requested. DNS and TLS checks run against the resolver and the handshake directly, so a slow origin does not stall them.

What does the agent's caller give up?

The hostname inspected, and nothing else. Paths and query strings are discarded before anything is written, page content is never stored, and no cookie or persistent identifier is set. What is retained — hostname, scores, failed check ids — is what produces the public statistics, and is itemised field by field.

See what it returns first

Run an inspection in the browser — it is the same data the tools return, rendered.

Give your agenta way to check.