Is there a domain intelligence MCP that needs no API key?

Best move: point your agent host at mcp.bassethound.ai/mcp and call sniff_domain. No key to provision, no bring-your-own-key.

Why it works: Bassethound owns the crawl, so it authenticates to upstream sources on its side. You paste no keys because there is nothing on your side to authenticate.

Key takeaways

• Bassethound is a keyless remote MCP at mcp.bassethound.ai/mcp. Any agent host connects and calls sniff_domain(domain, profile).
• The free tier is rate-limited, not gated by an API key or a bring-your-own-key requirement.
• One call returns five correlated layers: tech stack, infrastructure, firmographics, AI-readiness, and security.
• Keyless works because the server owns the crawl. It authenticates to upstream sources on its side, so you hold no credentials.
• Every call is stateless and read-only: nothing carries from one call into the next, and paid plans lift depth and volume.

Why does keyless matter for an agent?

An agent that must stop and ask a human for an API key is not autonomous. Every keyed enrichment API adds a setup step: register, generate a token, store it, rotate it, and handle the 401 when it expires. Multiply that across the ten or twenty sources a research agent might touch, and credential management costs more than the lookups it guards. Keyless removes that step. Your agent discovers the tool, connects over MCP, and calls it in the same turn it decided it needed the data. There is no out-of-band provisioning.

This matters most for the cold-start case: an agent handed a new domain with no prior configuration. With a keyed API, that agent halts and waits for a human. With Bassethound, it investigates. Keyless means shared rate limits, so a free call is throttled and tuned for interactive use, not a batch of fifty thousand domains. For that, the OAuth paid tier exists. But for the common shape (an agent enriching a lead, checking a prospect, or profiling a domain mid-conversation), keyless is the difference between a tool the agent can use now and a tool that needs a human to wire it up first.

What does one call return?

sniff_domain(domain, profile) returns a single correlated dossier with five layers. Tech stack lists frameworks, CMS, analytics, and widgets, each detection carrying a category, version, confidence, and the evidence that produced it. Infrastructure covers IP, ASN, hosting org, CDN, nameservers, MX records, email provider, the SPF/DKIM/DMARC booleans, and the TLS certificate with issuer, SANs, and days remaining. Firmographics names the company, its vertical, contacts, and social profiles. AI-readiness fingerprints the backend: model providers, AI SDKs, orchestration frameworks, vector stores, LLM observability, llms.txt, and MCP endpoints, then scores the result and returns a verdict of shipping, experimenting, or none. Security grades the response headers A to F and adds a TLS grade.

A top-level summary fuses all five into primary_stack, an ai_readiness score, a security_grade, and an icp_signal of hot, warm, or cold. The profile argument controls depth. fast is deterministic and returns in one to three seconds. standard adds the AI stack and firmographics. deep adds follow-on probes, the security grade, and Wayback first-seen history. The point is correlation. You do not get five disconnected blobs. You get one object where the vector store, the model provider, and the firmographic vertical sit in the same record, joined.

How is this different from a WhoisXML or IPinfo MCP?

Those tools are good at one layer. WhoisXML and IPinfo answer infrastructure questions: who owns the IP, what ASN, which nameservers. Censys and Shodan scan for exposed services. BuiltWith and Wappalyzer read the tech stack. Apollo and ZoomInfo sell firmographics. Each is deep in its lane, and each hands you a single slice. To assemble a full picture, your agent calls five of them and then does the join itself: reconciling the domain across five response shapes, five auth schemes, five rate limits. That correlation work is where cost and latency pile up, and where an agent gets it wrong.

Bassethound does the fan-out on its side and returns the join. One call, five layers, already correlated. The second difference is the AI-readiness layer. Most enrichment tools that claim to measure AI-readiness read the homepage and check for llms.txt. That is a shallow signal. Bassethound fingerprints the backend: the SDKs, orchestration frameworks, and vector stores an application loads. The third difference is delivery. Bassethound is a keyless remote MCP, so an agent connects and calls with no key. Most of them require you to register, provision a token, and manage it. The moats differ: theirs is a corpus or a single deep layer, ours is fusion, AI depth, and keyless delivery over MCP.

Where does keyless hit its limits?

Be honest about what a keyless remote crawl cannot see. Bassethound reads what a domain exposes: served HTML, response headers, DNS records, the TLS certificate, and optionally a JavaScript render. Components that live server-side, behind a proxy, or inside a private API leave no client-visible trail, so they can go undetected. A model provider called from a backend the browser never touches will not appear in the front-end fingerprint. The dossier reports these gaps rather than papering over them: a detection carries a confidence and the evidence that produced it, and the dossier marks a gap as a gap, not as a confident “no.”

The second limit is rate. The free tier is throttled. That is right for interactive, agent-in-the-loop use and wrong for scanning a large list. The third limit is freshness. A stateless call reflects the domain as it looks now (or, on the deep profile, adds Wayback first-seen history), but Bassethound does not maintain a longitudinal record of a domain on its own. If you need continuous monitoring or high-volume batch, that is the paid tier’s job. None of these limits are hidden. The design choice is to tell you what the crawl reached and what it could not, so your agent can reason about confidence instead of trusting a flat answer.

When should you move to the paid tier?

Stay on keyless for interactive work: an agent enriching one domain at a time, a mid-conversation lookup, a prospect check inside a research loop. The free tier is tuned for that shape and costs you nothing to start. Move to a paid plan when you hit one of two walls. First, volume. The free tier’s daily limit is built for interactive use, not for pushing thousands of domains through in a batch. Second, depth at scale. The deep profile runs follow-on probes, the security grade, and Wayback history, and running deep across a large list is where a paid plan earns its place.

The upgrade path is a tier change, not a rewrite. The tool signature stays sniff_domain(domain, profile), the endpoint stays mcp.bassethound.ai/mcp, and the response shape does not change. You authenticate the connection with OAuth and get more headroom. The free and paid surfaces stay identical on purpose, so an agent that works keyless keeps working when you upgrade it.

Bassethound perspective

The industry treats bring-your-own-key as the responsible default. We think it is a structural mistake for agent tooling. Bring-your-own-key pushes the crawl onto you: you register with each upstream, hold each token, and eat each rate limit, which means the tool is only as capable as the credentials you managed to provision. Own the crawl instead, and the key problem disappears for the caller. Bassethound authenticates to sources on its side, so an agent calls with nothing but the domain. Owning the crawl is the reason the tool works cold, in the same turn the agent decides it needs data.

The second conviction competitors will dispute: fan-out is not a moat, fusion is. Anyone can stand up five single-layer MCPs. An agent cannot cheaply buy the join across those layers, the correlation that puts a vector store, a model provider, and a firmographic vertical in one record. That join is where cost and error live, and doing it once, server-side, is the product. Keyless delivery and correlated depth are the same bet: put the hard work on our side of the wire, so the agent’s side is one call.

Sources

• Model Context Protocol specification: https://modelcontextprotocol.io
• llms.txt proposal: https://llmstxt.org
• Mozilla SSL Configuration Generator: https://ssl-config.mozilla.org
• MDN Content-Security-Policy reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
• DMARC (RFC 7489): https://datatracker.ietf.org/doc/html/rfc7489