Free Network Intelligence API: DNS Lookup, SSL Check & Email Security for AI Agents

DNS lookups, SSL certificate checks, email authentication records — these are things every developer needs to debug at some point, but they're surprisingly awkward to query programmatically. The command-line tools exist (dig, nslookup, openssl s_client), but they're hard to parse and unavailable in browser-based or agent environments.

Agent Media Tools exposes a set of free, no-signup REST endpoints for network intelligence. No API key is required for the anonymous daily allowance. Hit them from curl, Python, JavaScript, or any AI agent framework. This post covers the four most useful ones: DNS lookup, email security (SPF/DKIM/DMARC), SSL certificate inspection, and Open Graph preview.

Overview of the Free Endpoints

All endpoints live under https://agentmediatools.com/api/ and return JSON. Anonymous requests are limited to 10 successful tool calls per IP each day; a free account or API key raises the allowance to 25 per day.

This guide dives deep into the first four — the ones with the most network/infrastructure utility for developers and AI agents.

1. DNS Lookup — Query Any Record Type

Need to verify a CNAME, check MX records before deploying email, or debug a TXT record for domain ownership? GET /api/dns/lookup accepts a hostname and optional type parameter.

curl "https://agentmediatools.com/api/dns/lookup?hostname=github.com&type=ANY" | python3 -m json.tool

The response returns a structured JSON object grouped by record type. Record types with no result are omitted:

{
  "success": true,
  "hostname": "github.com",
  "type": "ANY",
  "records": {
    "A": ["192.0.2.10"],
    "AAAA": ["2001:db8::10"],
    "MX": [
      {"priority": 10, "exchange": "mail.example.net"}
    ],
    "TXT": ["v=spf1 include:_spf.example.net ~all"],
    "NS": ["ns1.example.net", "ns2.example.net"]
  }
}

You can also query a single record type directly:

# Get just MX records
curl "https://agentmediatools.com/api/dns/lookup?hostname=gmail.com&type=MX"

# Get just TXT records for domain verification
curl "https://agentmediatools.com/api/dns/lookup?hostname=example.com&type=TXT"

Valid record types: A, AAAA, MX, TXT, CNAME, NS, SOA, SRV, PTR, CAA, or ANY (default). Invalid hostnames return a clear success: false response rather than a cryptic connection error.

2. Email Security — SPF, DKIM & DMARC in One Call

Before sending email from a new domain, you need three DNS records configured: SPF (who can send), DKIM (cryptographic signing), and DMARC (what to do with failed mail). Checking all three manually requires three separate dig commands and a lot of parsing.

GET /api/dns/email-security returns all three in a single structured response:

curl "https://agentmediatools.com/api/dns/email-security?domain=example.com" | python3 -m json.tool

{
  "success": true,
  "domain": "example.com",
  "records": {
    "spf": "v=spf1 include:_spf.example.net ~all",
    "dkim": null,
    "dmarc": "v=DMARC1; p=reject"
  }
}

It queries:

• SPF — TXT record at the root domain starting with v=spf1
• DKIM — TXT record at default._domainkey.<domain> (the most common selector)
• DMARC — TXT record at _dmarc.<domain> starting with v=DMARC1

If any record is missing, its field is null rather than failing the whole request. This makes it ideal for automated email pre-flight checks in CI/CD or agent workflows.

import requests

r = requests.get("https://agentmediatools.com/api/dns/email-security", params={"domain": "example.com"})
data = r.json()
if data["success"]:
    spf = data["records"]["spf"]
    dmarc = data["records"]["dmarc"]
    if not spf:
        print("⚠️ No SPF record found — email may be spoofable")
    if dmarc and "p=reject" in dmarc:
        print("✅ DMARC reject policy is active")
    elif dmarc and "p=quarantine" in dmarc:
        print("⚠️ DMARC is set to quarantine (consider p=reject)")

3. SSL Certificate Checker — Inspect TLS in Real Time

Wondering when a certificate expires? Whether a SAN covers a subdomain? Which cipher suite the server negotiates? GET /api/ssl/check opens a real TLS connection and returns the full certificate details.

curl "https://agentmediatools.com/api/ssl/check?hostname=agentmediatools.com"

The response includes peer-certificate details, validity dates, fingerprints, subject alternative names (SANs), and connection metadata:

{
  "success": true,
  "hostname": "agentmediatools.com",
  "port": 443,
  "latency_ms": 124,
  "certificate": {
    "subject": {"CN": "agentmediatools.com"},
    "issuer": {"O": "Example CA", "CN": "Example Intermediate"},
    "fingerprint256": "AB:CD:12:34...",
    "valid_from": "2026-06-01T00:00:00.000Z",
    "valid_to": "2026-08-30T00:00:00.000Z",
    "days_remaining": 36,
    "days_total": 90,
    "expired": false,
    "expiring_soon": false,
    "sans": ["DNS:agentmediatools.com", "DNS:www.agentmediatools.com"],
    "self_signed": false
  },
  "cipher": {"name": "TLS_AES_256_GCM_SHA384", "version": "TLSv1.3"},
  "protocol": "TLSv1.3"
}

You can also specify a custom port (e.g., &port=8443) for non-default TLS services. The endpoint enforces a 10-second timeout and validates that the port is in the 1–65535 range.

import requests, sys

domain = sys.argv[1]
r = requests.get("https://agentmediatools.com/api/ssl/check", params={"hostname": domain})
cert = r.json().get("certificate", {})
days = cert.get("days_remaining", 0)
if days < 14:
    print(f"🚨 {domain} SSL cert expires in {days} days — renew now!")
else:
    print(f"✅ {domain} SSL cert OK ({days} days remaining)")

4. Open Graph Preview — Scrape Social Metadata

When an AI agent needs to summarize a link — extract the title, description, image, and Twitter card — GET /api/og-preview does the scraping in one call. No headless browser required.

curl "https://agentmediatools.com/api/og-preview?url=https://agentmediatools.com"

{
  "success": true,
  "og": {
    "url": "https://agentmediatools.com",
    "status": 200,
    "title": "Agent Media Tools — 70+ APIs for AI Agents",
    "og_title": "Agent Media Tools — 70+ APIs for AI Agents",
    "og_description": "Free browser tools, REST APIs, and MCP access for image processing, PDF manipulation, web scraping, and more.",
    "og_image": "https://agentmediatools.com/images/og-card.jpg",
    "og_type": "website",
    "twitter_card": "summary_large_image",
    "twitter_image": "https://agentmediatools.com/images/og-card.jpg",
    "description": "70+ free APIs and browser tools for AI agents.",
    "favicon": "https://agentmediatools.com/icons/icon.svg",
    "canonical": "https://agentmediatools.com/",
    "jsonld": true,
    "best_title": "Agent Media Tools — 70+ APIs for AI Agents",
    "best_description": "Free browser tools, REST APIs, and MCP access for image processing, PDF manipulation, web scraping, and more."
  }
}

The response normalizes relative URLs (favicon, og:image) to absolute URLs, resolves the best available title/description from OG → Twitter → HTML fallbacks, and reports whether JSON-LD structured data is present on the page.

import requests

def summarize_link(url):
    r = requests.get("https://agentmediatools.com/api/og-preview", params={"url": url})
    og = r.json().get("og", {})
    return {
        "title": og.get("best_title"),
        "description": og.get("best_description"),
        "image": og.get("og_image"),
        "type": og.get("og_type"),
    }

print(summarize_link("https://github.com/nousresearch/hermes"))

Using These from a Python AI Agent

All endpoints are compatible with any HTTP client. A LangChain, CrewAI, or Autogen agent can call them with plain requests or httpx. No API key, no SDK, no special headers:

class NetworkIntelligenceTool:
    """Tool for DNS, SSL, email security, and OG lookups."""
    
    BASE = "https://agentmediatools.com/api"
    
    def dns_lookup(self, hostname: str, type: str = "ANY") -> dict:
        r = requests.get(f"{self.BASE}/dns/lookup", params={"hostname": hostname, "type": type})
        return r.json()
    
    def email_security(self, domain: str) -> dict:
        r = requests.get(f"{self.BASE}/dns/email-security", params={"domain": domain})
        return r.json()
    
    def ssl_check(self, hostname: str) -> dict:
        r = requests.get(f"{self.BASE}/ssl/check", params={"hostname": hostname})
        return r.json()
    
    def og_preview(self, url: str) -> dict:
        r = requests.get(f"{self.BASE}/og-preview", params={"url": url})
        return r.json()

For a larger daily allowance, sign up for a free API key and explore all 70+ tools, including document and media processing endpoints. These four network-intelligence routes are REST endpoints rather than MCP tools.

What These Tools Don't Do

These are lightweight query APIs, not comprehensive security scanners. A few honest limitations:

• DNS — Uses Node.js built-in resolver, not a full recursive resolver. Results reflect what the server's upstream DNS provides.
• DKIM — Only checks the default selector. Some providers use custom selectors (e.g., google._domainkey).
• SSL — Does not enforce trust-chain validation. The current self_signed field reflects whether Node authorized the connection, so treat it as a trust warning rather than definitive proof of a self-signed certificate.
• OG Preview — Fetches static HTML only. JavaScript-rendered meta tags (SPA frameworks) are not captured.
• Usage limits — Anonymous calls share a 10-per-day IP allowance; free accounts and API keys receive 25 per day, while paid plans have a higher daily allowance.

Quick Reference

Here's a cheat sheet for the most common queries:

# DNS — check A record
curl "https://agentmediatools.com/api/dns/lookup?hostname=example.com&type=A"

# DNS — check MX for email delivery
curl "https://agentmediatools.com/api/dns/lookup?hostname=example.com&type=MX"

# Email security — complete SPF + DKIM + DMARC
curl "https://agentmediatools.com/api/dns/email-security?domain=example.com"

# SSL — certificate details + expiry
curl "https://agentmediatools.com/api/ssl/check?hostname=example.com"

# OG preview — social card for any URL
curl "https://agentmediatools.com/api/og-preview?url=https://example.com"

# Timezone — convert UTC to Pacific
curl "https://agentmediatools.com/api/timezone/convert?from=UTC&to=America/Los_Angeles&time=2026-07-25T12:00:00Z"

# Country — lookup by code
curl "https://agentmediatools.com/api/country/lookup?code=JP"

All endpoints return JSON. Pipe through python3 -m json.tool or jq for pretty-printing.

Why These Endpoints Matter for AI Agents

Traditional LLM tool-calling setups require agents to execute local shell commands to do DNS or SSL lookups. That's fragile — shell access is often restricted, parsing dig output is error-prone, and running openssl from an agent introduces security concerns. These REST endpoints give agents a safe, structured, and portable way to gather network intelligence without shell access or local tooling.

Whether you're building a DevOps assistant that checks certificate expiry, an email validation agent that verifies SPF/DKIM before a send, or a content crawler that extracts social previews — these free intelligence tools cover the basics without friction.