domain-security-mcp-server
This server is a read-only MCP toolkit for auditing email, DNS, and domain security, with no API keys required.
Email authentication audit: one-call SPF, DKIM, DMARC, and MX review with a 0–100 score, A–F grade, and prioritized fixes.
Per-record checks: inspect SPF, DMARC, DKIM, MTA-STS, TLS-RPT, BIMI, and DNSSEC records.
DNS utilities: look up A/AAAA/CNAME/MX/NS/TXT/SOA, MX servers, reverse DNS, and DNS propagation across resolvers.
TLS/SSL inspection: certificate issuer, validity window, expiry warnings, SANs, and fingerprint.
WHOIS lookups: registrar, dates, name servers, status, and raw WHOIS data.
IP intelligence: offline geolocation and reverse DNS.
Web security: grade HTTP security headers such as HSTS, CSP, X-Frame-Options, and COOP.
Email header analysis: parse Authentication-Results verdicts and Received hop chains with delays.
Reputation checks: query DNSBL blacklists and CAA certificate-authority records.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@domain-security-mcp-server Audit email security for google.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
domain-security-mcp-server
An MCP server that lets an AI agent audit the email and domain security of any domain — SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI, DNSSEC, DNS, TLS/SSL and WHOIS — in plain language. No API keys required.
Built on the v2 MCP SDK: the server speaks the 2026-07-28 protocol revision and keeps accepting 2025-era clients (Claude Desktop, Claude Code, Cursor) from the same factory — the era is negotiated per connection, so there is nothing to configure on either side.
Ask Claude "Is acme.com protected against email spoofing?" and it runs a full authentication audit and hands you a graded report with prioritised fixes — instead of you pasting a domain into five different web tools.
> Is ortamarco.me protected against email spoofing?
email_auth_audit(domain="ortamarco.me")
Grade: A (95/100) · MX: present
✅ SPF ends in '-all' (hard fail). 3/10 DNS lookups.
✅ DMARC policy is enforced ('p=reject').
✅ DKIM key found for selector: google.
Top recommendation: add a TLS-RPT record for delivery-failure reports.Why this exists
The email-security ecosystem is full of single-purpose web checkers (SPF here, DMARC there, WHOIS somewhere else) and the few MCP equivalents are locked behind paid API tokens. This server brings the whole deliverability & domain-security toolkit to any MCP client, key-free, with one headline workflow tool that does the synthesis for you.
It is the agent-facing companion to the network tools at ortamarco.me and shares the same battle-tested core (public-resolver DNS, host validation, timeouts).
Related MCP server: DnsGuard
Tools
Tool | What it does |
| One-call SPF + DKIM + DMARC + MX audit → 0–100 score, A–F grade, prioritised fixes |
| Parse SPF; recursively count DNS lookups vs the RFC 7208 limit of 10; flag |
| Parse the DMARC record (every tag is returned) and flag a missing or invalid |
| Probe |
| Validate the |
| Check the |
| Check the |
| DS/DNSKEY presence + DNSSEC |
| All record types (A/AAAA/CNAME/MX/NS/TXT/SOA) via public resolvers |
| TLS cert issuer, validity window, days-to-expiry, SANs, fingerprint |
| Registrar, dates, name servers, status (raw port-43 WHOIS, IANA-resolved) |
| PTR records for an IP |
| Offline IP geolocation (DB-IP Lite) + reverse DNS |
| Mail servers (MX) with priority and resolved IPs |
| Which CAs may issue TLS certificates (CAA records) |
| IP/domain against open-access email DNSBLs |
| Compare a record across 5 public resolvers worldwide |
| Grade a site's HSTS, CSP, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy and COOP (an HSTS |
| Parse raw headers → SPF/DKIM/DMARC verdicts + Received hop chain with delays |
Every tool is read-only, declares an outputSchema and returns
structuredContent (validated by the SDK) alongside human-readable Markdown
(default) or JSON (response_format="json"), plus actionable error messages.
Install
Requires Node.js 20.18+. Nothing to clone — every MCP client can run it with npx.
Use it with Claude Code
claude mcp add domain-security -- npx -y domain-security-mcp-serverUse it with Claude Desktop or Cursor
Add to claude_desktop_config.json (or ~/.cursor/mcp.json) — see examples/:
{
"mcpServers": {
"domain-security": {
"command": "npx",
"args": ["-y", "domain-security-mcp-server"]
}
}
}On Windows use "command": "cmd" with "args": ["/c", "npx", "-y", "domain-security-mcp-server"].
Restart the client, then ask: "Audit the email security of stripe.com."
Self-host (HTTP transport)
The same server speaks stateless Streamable HTTP for remote or multi-client
use. One endpoint serves both protocol eras and there is no session state, so no
Mcp-Session-Id header is issued or expected.
TRANSPORT=http npx -y domain-security-mcp-server
# POST JSON-RPC to http://127.0.0.1:3000/mcp · health at /healthzIt is safe by default: it binds to 127.0.0.1 and only accepts localhost
Host and Origin headers, which blocks DNS-rebinding attacks from a web page.
To expose it — for example behind Coolify or Traefik — opt in explicitly:
Variable | Default | Purpose |
|
|
|
|
| Listening port |
|
| Bind address; |
| — | Comma-separated hostnames the |
| — | Comma-separated origins allowed to call from a browser |
| — | If set, every request needs |
Binding to a non-loopback address without ALLOWED_HOSTS or MCP_AUTH_TOKEN
works, but the server says so on stderr. With Docker (the image sets HOST=0.0.0.0):
docker build -t domain-security-mcp .
docker run -p 3000:3000 -e ALLOWED_HOSTS=mcp.example.com -e MCP_AUTH_TOKEN=change-me domain-security-mcpSecurity
The tools reach out to hosts that the caller names, so every outbound connection is screened against server-side request forgery:
Private, loopback, link-local (cloud metadata), shared, multicast and reserved addresses are refused in every spelling, including IPv4 embedded in IPv6 (
[::ffff:169.254.169.254]).The check happens at connect time, on the address the socket is actually about to use, so DNS rebinding and names only an internal resolver knows are refused too. Redirects are followed by hand and every hop is re-checked.
Response bodies, redirects, WHOIS referrals and every network call are capped and time-limited.
Found a problem? Please open a private security advisory.
Develop
npm run dev # tsx watch (stdio)
npm run inspect # open the MCP Inspector against the built server
npm run build # type-check + emit dist/
npm run typecheck # type-check only
npm test # offline unit tests: SSRF guard, SPF/DMARC/DKIM scoring,
# header parsing, HTTP transport defaults
npm run smoke # call all 19 tools on BOTH protocol eras and validate
# structuredContent against each tool's outputSchemaevals/ holds a 10-question LLM evaluation set (stable, verifiable)
and instructions for running it — see evals/README.md.
How it works
src/
├── index.ts # transport selection (stdio | http), v2 SDK entry points
├── server.ts # factory: registers every tool on one McpServer
├── core/ # pure logic, no MCP coupling — reusable & testable
│ ├── validate.ts # input validation and the address classifier
│ ├── netguard.ts # connect-time SSRF guard, redirect-safe fetch, capped bodies
│ ├── dns.ts # public-resolver DNS + DoH client
│ ├── net.ts # MX, CAA, DNSBL and propagation checks
│ ├── tls.ts # certificate inspection and trust
│ ├── whois.ts # port-43 WHOIS with IANA/registrar referral
│ ├── http.ts # security-header grading
│ ├── geoip.ts # offline IP geolocation on DB-IP Lite (each file read on first use)
│ ├── email-headers.ts # raw header parsing and hop timing
│ └── email-auth.ts # SPF/DKIM/DMARC/MTA-STS/TLS-RPT/BIMI/DNSSEC + scoring
└── tools/ # thin MCP wrappers (Zod schemas, descriptions, formatting)The core/ layer is deliberately free of any MCP types, so the exact same logic
powers both this server and the web tools on ortamarco.me.
Credits
IP Geolocation by DB-IP. ip_geolocation uses the
free DB-IP "IP to City Lite" database, licensed under
CC BY 4.0 and installed as the
@ip-location-db/dbip-city-mmdb
package; the credit also appears in the tool's description and Markdown output. The
database has no time zone, so time_zone is estimated from the coordinates with
@photostructure/tz-lookup (CC0).
License
MIT © Marco Orta
Available Tools
19 toolsanalyze_email_headersEmail Header AnalyzerARead-onlyIdempotent
Parse raw email headers and report the SPF/DKIM/DMARC verdicts (from Authentication-Results), key fields (From, Subject, Date, Message-ID, Return-Path) and the Received hop chain with per-hop delays and total transit time.
Args:
headers (string): the raw email headers.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { auth{spf,dkim,dmarc}, fields{}, hops[{index,from,by,date,delaySec}], totalSec }.
Example: paste the headers from "Show original" in Gmail to trace a message's path and authentication.
Inputs: headers (required), response_format. Returns: auth, hops, fields, totalSec
bimi_checkBIMI CheckARead-onlyIdempotent
Check a domain's BIMI record (default._bimi. TXT), which points to the brand logo (and optional VMC) displayed next to authenticated mail. BIMI requires an enforced DMARC policy to take effect.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { found, record, findings[] }.
Example: "Does cnn.com have BIMI set up?" -> bimi_check(domain="cnn.com").
Inputs: domain (required), response_format. Returns: found, domain, record, findings
blacklist_checkDNSBL Blacklist CheckARead-onlyIdempotent
Check whether an IPv4 address (or a domain's A records) appears on email DNS blocklists (DNSBLs). Only open-access lists are queried (SpamCop, UCEPROTECT-1, DroneBL, s5h); Spamhaus and Barracuda refuse public-resolver queries and are excluded.
Args:
query (string): an IPv4 address or a domain.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { ips[], listedCount, checked, results[{ip, hits[{list, listed, reason, error}]}], note }. A list that did not answer carries an error and is not counted as clean.
Example: "Is 203.0.113.5 blacklisted?" -> blacklist_check(query="203.0.113.5").
Inputs: query (required), response_format. Returns: ips, note, query, checked, +2 more
caa_checkCAA Record CheckARead-onlyIdempotent
Check a domain's CAA (Certification Authority Authorization) records — which CAs are allowed to issue TLS certificates for it. Absence means any CA may issue.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { found, issue[], issuewild[], iodef[] }.
Example: "Which CAs can issue certs for google.com?" -> caa_check(domain="google.com").
Inputs: domain (required), response_format. Returns: found, iodef, issue, domain, +1 more
dkim_checkDKIM Record CheckARead-onlyIdempotent
Look up DKIM public keys at ._domainkey.. Because DKIM selectors are arbitrary and undiscoverable, you should pass the selector(s) your mail provider uses for a definitive answer; otherwise a curated list of common selectors is probed and a miss is inconclusive.
Args:
domain (string): the domain to check.
selectors (string[], optional): DKIM selectors to probe.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { any_found, probed_selectors, selectors[{selector, found, record, key_type}], findings[] }.
Examples:
"Does acme.com publish a DKIM key for selector 'google'?" -> dkim_check(domain="acme.com", selectors=["google"])
"Find any DKIM keys for acme.com" -> dkim_check(domain="acme.com")
Inputs: domain (required), selectors, response_format. Returns: domain, findings, any_found, selectors, +1 more
dmarc_checkDMARC Record CheckARead-onlyIdempotent
Fetch and parse a domain's DMARC record (_dmarc.). Reports the policy (p=), subdomain policy (sp=), reporting addresses (rua/ruf), pct and alignment (aspf/adkim), and warns on monitor-only or partial deployments.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { found, record, policy, tags{}, findings[] }.
Example: "What is paypal.com's DMARC policy?" -> dmarc_check(domain="paypal.com").
Inputs: domain (required), response_format. Returns: tags, found, domain, policy, +2 more
dns_lookupDNS LookupARead-onlyIdempotent
Resolve all common DNS record types (A, AAAA, CNAME, MX, NS, TXT, SOA) for a domain in one call, using public resolvers (Cloudflare/Google/Quad9).
Args:
domain (string): the domain to query, e.g. "example.com".
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: a map of record type -> list of records. Each record has { type, host, value, priority? }.
Examples:
"What are the MX records for stripe.com?" -> dns_lookup(domain="stripe.com")
Use ssl_certificate for TLS details, whois_lookup for registration data.
Errors: returns an error if the domain is malformed or has no resolvable records.
Inputs: domain (required), response_format. Returns: domain, records
dns_propagationDNS Propagation CheckARead-onlyIdempotent
Compare a domain's DNS records across multiple public resolvers worldwide (Cloudflare, Google, Quad9, OpenDNS, AdGuard) to see whether a change has propagated.
Args:
domain (string): the domain to check.
type ('A'|'AAAA'|'CNAME'|'MX'|'NS'|'TXT'): record type (default 'A').
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { type, consistent, resolvers[{name, server, values[], error}] }.
Example: "Has the A record for example.com propagated?" -> dns_propagation(domain="example.com").
Inputs: domain (required), type, response_format. Returns: type, domain, resolvers, consistent
dnssec_checkDNSSEC CheckARead-onlyIdempotent
Check whether a domain is protected by DNSSEC. Queries DS and DNSKEY records over DNS-over-HTTPS and reads the resolver's Authenticated Data (AD) flag to confirm the chain of trust validates.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { enabled, validated, ds_records, dnskey_records, findings[] }.
Example: "Is cloudflare.com DNSSEC-signed?" -> dnssec_check(domain="cloudflare.com").
Inputs: domain (required), response_format. Returns: domain, enabled, findings, validated, +2 more
email_auth_auditEmail Authentication AuditARead-onlyIdempotent
Headline tool. Audits a domain's email-authentication posture in one call — SPF, DKIM, DMARC and MX — then returns a 0–100 score, an A–F grade and a prioritised list of fixes. Use this first; reach for the per-record tools (spf_check, dmarc_check, dkim_check) only when you need the full detail of one mechanism.
Args:
domain (string): the domain to audit.
dkim_selectors (string[], optional): DKIM selectors to probe. If omitted, common provider selectors are tried (absence is then inconclusive).
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns (JSON): { "domain": string, "grade": "A".."F", "score": number, // 0-100 "has_mx": boolean, "mx_hosts": string[], "spf": { found, record, all_qualifier, lookup_count, exceeds_lookup_limit, findings[] }, "dmarc":{ found, policy, tags, findings[] }, "dkim": { any_found, selectors[], findings[] }, "top_recommendations": string[] }
Examples:
"Is example.com protected against email spoofing?" -> email_auth_audit(domain="example.com")
"Audit acme.com, our DKIM selector is 'k1'" -> email_auth_audit(domain="acme.com", dkim_selectors=["k1"])
Errors: returns an error only if the domain is malformed; missing records are reported as findings, not errors.
Inputs: domain (required), dkim_selectors, response_format. Returns: spf, dkim, dmarc, grade, +5 more
http_security_headersHTTP Security HeadersARead-onlyIdempotent
Fetch a URL and grade its HTTP security headers (HSTS, Content-Security-Policy, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy, COOP). Returns a 0–100 score, an A–F grade, and per-header notes.
Args:
url (string): URL or host to check (scheme defaults to https://).
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { url, final_url, status, grade, score, checks[{header, present, value, note}], missing[] }.
Example: "Grade the security headers on https://news.ycombinator.com" -> http_security_headers(url="https://news.ycombinator.com"). Errors: returns an error if the URL is invalid or the host is unreachable.
Inputs: url (required), response_format. Returns: url, grade, score, checks, +3 more
ip_geolocationIP GeolocationARead-onlyIdempotent
Geolocate an IP address (country, region, city, coordinates, time zone) using the offline DB-IP Lite database, plus its reverse-DNS hostname. No external API.
Args:
ip (string): IPv4 or IPv6 address.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { ip, country_iso, country_name, region, city, latitude, longitude, time_zone, hostname }.
Example: "Where is 151.101.1.69 located?" -> ip_geolocation(ip="151.101.1.69"). Note: geolocation is approximate (city-level at best) and offline data may lag reality. The time zone is estimated from the coordinates. Data: IP Geolocation by DB-IP (https://db-ip.com), licensed CC BY 4.0 — credit it when showing these results.
Inputs: ip (required), response_format. Returns: ip, city, region, hostname, +5 more
mta_sts_checkMTA-STS CheckARead-onlyIdempotent
Check a domain's MTA-STS deployment: the _mta-sts TXT record AND the policy file at https://mta-sts./.well-known/mta-sts.txt. Reports the enforcement mode (enforce/testing/none) and the listed MX hosts. MTA-STS forces TLS for inbound SMTP and blocks downgrade attacks.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { dns_record_found, policy_found, mode, policy{}, findings[] }.
Example: "Does gmail.com enforce MTA-STS?" -> mta_sts_check(domain="gmail.com").
Inputs: domain (required), response_format. Returns: mode, domain, policy, findings, +2 more
mx_lookupMX LookupARead-onlyIdempotent
Look up a domain's mail servers (MX records) with priority and the IPs they resolve to.
Args:
domain (string): the domain to query.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: array of { exchange, priority, ips[] }.
Example: "What are the mail servers for github.com?" -> mx_lookup(domain="github.com").
Inputs: domain (required), response_format. Returns: domain, records
reverse_dnsReverse DNS (PTR)ARead-onlyIdempotent
Resolve the PTR (reverse DNS) records for an IP address — the hostname(s) the IP maps back to.
Args:
ip (string): IPv4 or IPv6 address.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { ip, hostnames: string[] }.
Example: "What hostname does 8.8.8.8 reverse to?" -> reverse_dns(ip="8.8.8.8"). Errors: returns an error if the IP is invalid or has no PTR record.
Inputs: ip (required), response_format. Returns: ip, hostnames
spf_checkSPF Record CheckARead-onlyIdempotent
Fetch and analyse a domain's SPF record. Detects: missing/multiple records, the trailing 'all' qualifier (+all/?all/~all/-all), and counts DNS-querying terms recursively against the RFC 7208 limit of 10.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { found, record, multiple_records, all_qualifier, lookup_count, exceeds_lookup_limit, findings[] }.
Example: "Does sendgrid.net's SPF exceed the 10-lookup limit?" -> spf_check(domain="sendgrid.net").
Inputs: domain (required), response_format. Returns: found, domain, record, findings, +4 more
ssl_certificateSSL/TLS Certificate InspectorARead-onlyIdempotent
Inspect the TLS certificate served by a host: issuer, subject, validity window, days-until-expiry, SANs, serial and SHA-256 fingerprint. Flags expired or soon-to-expire certificates.
Args:
domain (string): host to connect to.
port (number): TLS port (default 443).
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: certificate fields plus { days_until_expiry, expired, expires_soon, trusted, hostname_matches, authorization_error }. An untrusted certificate (self-signed, unknown root, wrong host) is still inspected and reported, never silently passed.
Example: "When does github.com's certificate expire?" -> ssl_certificate(domain="github.com"). Errors: returns an error if the host is unreachable or serves no certificate.
Inputs: domain (required), port, response_format. Returns: host, port, expired, trusted, +12 more
tls_rpt_checkTLS-RPT CheckARead-onlyIdempotent
Check a domain's TLS-RPT record (_smtp._tls. TXT). TLS-RPT lets you receive reports about TLS delivery failures to your domain.
Args:
domain (string): the domain to check.
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { found, record, findings[] }.
Example: "Does microsoft.com publish TLS-RPT?" -> tls_rpt_check(domain="microsoft.com").
Inputs: domain (required), response_format. Returns: found, domain, record, findings
whois_lookupWHOIS LookupARead-onlyIdempotent
Look up domain registration data over the raw WHOIS protocol (port 43): registrar, creation/update/expiry dates, name servers and domain status. Resolves the correct WHOIS server via IANA and follows registrar referrals. No API key.
Args:
domain (string): the domain to look up.
response_format ('markdown' | 'json'): output format (default 'markdown'). JSON includes the raw WHOIS text.
Returns: { domain, registrar, created, updated, expires, name_servers[], status[], whois_server }.
Example: "Who is the registrar for openai.com and when does it expire?" -> whois_lookup(domain="openai.com"). Errors: returns an error if no WHOIS server answers (some ccTLDs restrict or rate-limit WHOIS).
Inputs: domain (required), response_format. Returns: raw, domain, status, created, +6 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Each tool targets a distinct security check (SPF, DMARC, DKIM, MTA-STS, TLS-RPT, BIMI, DNSSEC, CAA, etc.), and the aggregate email_auth_audit is explicitly positioned as the entry point versus the per-record detail tools. Minor overlap exists between dns_lookup and mx_lookup, but descriptions clarify their different purposes.
Names are consistently snake_case and mostly follow a resource_check or resource_lookup pattern, which is predictable. A few deviations like email_auth_audit, reverse_dns, http_security_headers, and analyze_email_headers break the strict pattern but remain readable and recognizable.
19 tools is on the heavy side and exceeds the comfortable 15-tool threshold, though the breadth is somewhat justified by covering email authentication, DNS, TLS, web headers, WHOIS, and blacklists. It is not excessive enough to feel chaotic, but it is borderline for an MCP server.
For a read-only domain security auditor, the surface is remarkably complete: email authentication, DNSSEC/CAA, TLS certificates, HTTP security headers, WHOIS, blacklists, and email header forensics are all covered. The aggregate audit plus per-record detail tools form a coherent workflow with no major dead ends.
Maintenance
Related MCP Connectors
Inspect any domain: tech stack, SPF/DKIM/DMARC/MX email health and security posture, for AI agents
Email verification and domain intelligence for AI agents. MX, RDAP, SSL checks. 25 free credits.
Free SPF, DKIM, DMARC, blacklist, MX and bounce checks for any domain, as MCP tools for AI agents.
Email security and AI discoverability scores for any domain, with the exact record or tag to fix.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables AI agents to perform passive security scans on domains, checking email spoofing (DMARC/SPF/DKIM), TLS weaknesses, security headers, exposed files, and subdomain-takeover risk without needing an API key.777 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to check a domain's email authentication and health across SPF, DKIM, DMARC, BIMI, MX, MTA-STS, and TLS-RPT, returning a score and recommended fixes.MIT
- AlicenseAqualityCmaintenanceEnables AI agents to inspect any public domain’s web technology stack, email deliverability and DNS health (MX, SPF, DKIM, DMARC, MTA-STS, TLS-RPT, BIMI), and HTTPS security posture with typed JSON scores and remediation-ready findings, plus history, bulk checks, monitoring alerts, and reverse technology lookups.1261 npmMIT

lookproof-mcpofficial
AlicenseNot gradedqualityBmaintenanceDNS and email security checks for AI agents: SPF, DKIM, DMARC, MTA-STS, DNSSEC, TLS and more, with a fix for every finding. Pay per call in USDC on Base via x402, with dry run by default and a per-session spending cap.MIT