Give your agent access to every API

Three ways to integrate, from zero-effort to full control.

Recommended

Option A: Use the Gateway MCP

The fastest path. Install one MCP server and your agent can discover and use any API — no per-service plugins, no configuration files.

Install

npm install -g agent-gateway-mcp
agent-gateway init   # Sign in with Google → done

MCP client config (Claude Desktop, Cursor, etc.)

{
  "mcpServers": {
    "gateway": {
      "command": "agent-gateway-mcp"
    }
  }
}

That's it. Your agent now has 6 tools:

discover	Search services by intent, explore domains, drill into capabilities
call	Call any capability — auth, request building, and execution handled automatically
auth	Connect to services via OAuth2 or API key
subscribe	Subscribe to paid service plans (with user confirmation)
manage_subscriptions	List, cancel, upgrade, or downgrade subscriptions
list_connections	View connected services, token status, and subscription info

Example conversation

User: "Send an invoice to Acme Corp for $5,000"

Agent → discover({ query: "create invoice" })
Agent → discover({ domain: "api.invoiceninja.com", capability: "create_invoice" })
Agent → call({
  domain: "api.invoiceninja.com",
  capability: "create_invoice",
  params: { client_name: "Acme Corp", amount: 500000, currency: "USD" }
})

Agent: "Done! Invoice INV-2024-0042 sent to Acme Corp."

Option B: Query the registry API directly

If you're building your own agent framework, use the registry REST API to discover services.

Search for services (TypeScript)

const res = await fetch(
  "https://agentdns.dev/api/discover?q=send+email"
);
const { data } = await res.json();

// data = [
//   {
//     service: { name: "MailForge", domain: "api.mailforge.dev", ... },
//     matching_capabilities: [
//       { name: "send_email", description: "Send an email", detail_url: "..." }
//     ]
//   }
// ]

Fetch a service's manifest

const manifest = await fetch(
  "https://api.mailforge.dev/.well-known/agent"
).then(r => r.json());

// manifest.capabilities → list of all capabilities
// Each has a detail_url for drill-down

Drill into a capability

const detail = await fetch(
  "https://api.mailforge.dev/api/capabilities/send_email"
).then(r => r.json());

// detail.endpoint → "/v1/messages/send"
// detail.method → "POST"
// detail.parameters → [{ name: "to", type: "string", required: true, ... }]
// detail.request_example → full example request
// detail.response_example → full example response

See the full API Reference for all endpoints.

Option C: Fetch manifests directly

If you already know which services you want, skip the registry and fetch /.well-known/agent directly.

Python

import httpx

# Fetch the manifest
manifest = httpx.get("https://api.example.com/.well-known/agent").json()

# Find the capability you need
cap = next(c for c in manifest["capabilities"] if c["name"] == "send_email")

# Fetch its details
detail_url = f"{manifest['base_url']}{cap['detail_url']}"
detail = httpx.get(detail_url).json()

# Now you know the endpoint, method, parameters, and examples
print(f"{detail['method']} {detail['endpoint']}")
print(f"Params: {[p['name'] for p in detail['parameters']]}")

This is the lowest-level approach. You handle discovery, auth, and request construction yourself. Good for simple integrations or when you want full control.

Security

The registry provides trust signals to help your agent make safe choices. Pay attention to trust levels when presenting services to users.

Trust levels

[VERIFIED] — Service hosts its own manifest. Crawled periodically. Prioritized in results.

[COMMUNITY] — Maintained by AgentDNS. Trusted but not self-hosted.

[UNVERIFIED] — Not reviewed. Hidden from results by default. Pass include_unverified=true to see them.

Best practices

✓Prefer verified services when multiple options match a query.
✓Warn users before connecting to unverified services.
✓Never auto-approve payments. Always require user confirmation.
✓Use the Security docs for full details on rate limits and reporting.

Which option should I use?

Gateway MCP — Use this if you're using Claude, GPT, or any MCP-compatible agent. Zero code, maximum capability.

Registry API — Use this if you're building your own agent framework and want semantic search across all registered services.

Direct fetch — Use this for simple scripts, known services, or when you want full control over the integration.