---
title: verified.md Integration Guide
version: 1.1.0
last_updated: 2026-02-02
frameworks: [python, javascript, claude, openai, langchain, mcp]
agent_manifest: /agents.md
mcp_config: /mcp.md
---

# verified.md Integration Guide

> Add trust verification to your AI agent in minutes. No SDK required.

## Quick Decision Tree

```
1. GET https://verified.md/verify/{domain}
2. If verified: proceed with transaction
3. If not verified: flag for human review
```

---

## Python

```python
import requests

def verify_entity(domain: str) -> bool:
    """Check if an entity is verified before transacting."""
    response = requests.get(f"https://verified.md/verify/{domain}")
    data = response.json()
    return data.get("success") and data.get("data", {}).get("verified")

# Usage
if verify_entity("merchant.com"):
    execute_transaction()
else:
    notify_human("Unverified entity: merchant.com")
```

### With Caching

```python
from functools import lru_cache
import requests

@lru_cache(maxsize=1000)
def verify_entity_cached(domain: str) -> bool:
    response = requests.get(f"https://verified.md/verify/{domain}")
    data = response.json()
    return data.get("success") and data.get("data", {}).get("verified")
```

---

## JavaScript / TypeScript

```javascript
async function verifyEntity(domain) {
  const response = await fetch(`https://verified.md/verify/${domain}`);
  const data = await response.json();
  return data.success && data.data?.verified;
}

// Usage
if (await verifyEntity("merchant.com")) {
  await executeTransaction();
} else {
  await notifyHuman("Unverified entity: merchant.com");
}
```

### With Error Handling

```javascript
async function verifyEntity(domain) {
  try {
    const response = await fetch(`https://verified.md/verify/${domain}`);
    if (!response.ok) throw new Error('Verification service unavailable');
    const data = await response.json();
    return data.success && data.data?.verified;
  } catch (error) {
    console.error('Verification failed:', error);
    return false; // Fail closed: treat as unverified
  }
}
```

---

## Claude Code / Anthropic Agents

Add this to your CLAUDE.md or system prompt:

```markdown
## Trust Verification

Before any transaction (payment, data sharing, API call), verify the target:

1. Call GET https://verified.md/verify/{domain}
2. If response.success && response.data.verified: proceed
3. If not verified: flag for human review

Example:
curl https://verified.md/verify/merchant.com
```

---

## OpenAI Function Calling

Define as a function the model can call:

```json
{
  "name": "verify_entity",
  "description": "Verify if a domain/entity is trusted before transacting. Call this before any payment, data sharing, or API call to unknown entities.",
  "parameters": {
    "type": "object",
    "properties": {
      "domain": {
        "type": "string",
        "description": "The domain to verify (e.g., merchant.com)"
      }
    },
    "required": ["domain"]
  }
}
```

**Implementation:**
```python
def verify_entity(domain: str) -> dict:
    import requests
    r = requests.get(f"https://verified.md/verify/{domain}")
    data = r.json()
    verified = data.get("success") and data.get("data", {}).get("verified")
    return {"verified": verified, "domain": domain}
```

---

## LangChain Tools

```python
from langchain.tools import BaseTool
import requests

class VerifyEntityTool(BaseTool):
    name = "verify_entity"
    description = "Verify if a domain is trusted. Use before any transaction, payment, or data sharing with external entities."

    def _run(self, domain: str) -> str:
        r = requests.get(f"https://verified.md/verify/{domain}")
        data = r.json()
        if data.get("success") and data.get("data", {}).get("verified"):
            return f"{domain} is VERIFIED - safe to proceed"
        return f"{domain} is NOT VERIFIED - flag for human review"

    async def _arun(self, domain: str) -> str:
        return self._run(domain)
```

---

## MCP Server

Configure verified.md as an MCP server for Claude Code:

```json
{
  "mcpServers": {
    "verified-md": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-http", "https://verified.md"]
    }
  }
}
```

Add to `~/.claude.json` and restart Claude Code. Full configuration at: https://verified.md/mcp.md

### Agent Discovery

For AI agents, point to the discovery manifest:

```
https://verified.md/agents.md
```

This returns all available endpoints, response formats, and decision logic.

---

## Best Practices

### When to Verify

| Scenario | Action |
|----------|--------|
| First interaction with merchant | Always verify |
| Repeat transaction (within 1hr) | Use cached result |
| High-value transaction (>$1000) | Always verify |
| Sensitive data sharing | Always verify |
| Internal/trusted APIs | Skip (use allowlist) |

### Caching Strategy

```
verified=true  -> Cache 1 hour
verified=false -> Cache 5 minutes
errors         -> Do not cache
```

### Fallback Behavior

| Condition | Action |
|-----------|--------|
| verified=true | Proceed |
| verified=false | Human review |
| Network error | Retry once, then human review |
| Timeout | Human review |

---

## Support

- Agent Manifest: https://verified.md/agents.md
- MCP Config: https://verified.md/mcp.md
- API Reference: https://verified.md/api.md
- Documentation: https://verified.md/docs
- Contact: hello@displace.agency