> ## Documentation Index
> Fetch the complete documentation index at: https://docs.limitguard.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Discovery

> Machine-readable discovery for AI agents: MCP, A2A, x402, and llms.txt

Limitguard publishes machine-readable discovery files for three AI agent protocols. All discovery endpoints are **free and require no authentication**.

## Discovery Endpoints

| Endpoint | Protocol | Purpose |
| - | - | - |
| `GET /.well-known/x402.json` | x402 Bazaar | AI marketplace service listing with pricing |
| `GET /.well-known/agent.json` | A2A (Agent-to-Agent) | Agent Card for capability discovery |
| `GET /.well-known/mcp.json` | MCP (Model Context Protocol) | Tool manifest for LLM agents |
| `GET /.well-known/security.txt` | RFC 9116 | Security contact information |
| `GET /llms.txt` | llms.txt | Concise LLM-readable API summary |
| `GET /llms-full.txt` | llms.txt | Full LLM-readable API reference |

<Note>
  All `/.well-known/*` requests bypass x402 payment middleware completely: no payment or API key needed.
</Note>

## x402 Bazaar Listing

Enables AI agents to discover available endpoints and their payment requirements automatically.

```bash theme={null}
curl https://api.limitguard.ai/.well-known/x402.json
```

```json Response theme={null}
{
  "service": "Limitguard.ai",
  "version": "1.0",
  "protocol": "x402-v2",
  "x402Version": 2,
  "discoverable": true,
  "description": "Limitguard is a lead validation service for lead generation agencies, B2B marketing and sales teams: it checks the company behind each lead against official business registers (full coverage in the Netherlands and Belgium), EU VAT and sanctions lists, ...",
  "capabilities": ["lead_verification", "entity_verification", "risk_scoring", "reputation_tracking", "compliance_monitoring", "wallet_verification"],
  "endpoints": [
    {
      "path": "/v1/entity/check",
      "method": "POST",
      "price_usdc": 1.05,
      "price_raw": 1050000,
      "description": "Full entity trust check across multiple verification layers: ...",
      "category": "trust_intelligence"
    },
    {
      "path": "/v1/leads/verify",
      "method": "POST",
      "price_usdc": 0.27,
      "price_raw": 270000,
      "description": "Lead verify for one NL or BE sales lead: is it a real, active company? ...",
      "category": "other"
    }
  ]
}
```

Trimmed here: the live response lists every priced endpoint, each with its `inputSchema`, plus `payment` (networks and assets), `extensions`, `a2a` and `sla` blocks. `price_raw` is the default (`fresh`) price in USDC 6-decimal units. See [Pricing](/pricing) for the complete, current table.

Also available at `/v1/sales/listing` for the same data.

## A2A Agent Card

Google's Agent-to-Agent (A2A) protocol for agent capability discovery.

```bash theme={null}
curl https://api.limitguard.ai/.well-known/agent.json
```

Returns capabilities, skills, and how to invoke Limitguard as an A2A agent. Other agents can discover what Limitguard can do and how to interact with it programmatically.

## MCP Manifest

Model Context Protocol tools for LLM agents (Claude, GPT-4, etc.).

```bash theme={null}
curl https://api.limitguard.ai/.well-known/mcp.json
```

Returns tool definitions that LLM agents can use to call Limitguard endpoints as native tools. See the [AI Agent Integration guide](/guides/ai-agent-integration) for usage examples.

## llms.txt

Standard machine-readable format for LLM consumption.

```bash theme={null}
# Concise summary for quick context loading
curl https://api.limitguard.ai/llms.txt

# Full reference with all endpoints, pricing, and examples
curl https://api.limitguard.ai/llms-full.txt
```

## Cross-Sell Recommendations

AI agents calling one endpoint can discover complementary services:

```bash theme={null}
curl "https://api.limitguard.ai/v1/sales/recommendations?current_endpoint=/v1/risk/score" \
  -H "X-API-Key: lg_live_xxxxxxxxxxxxxxxxxxxx"
```

Needs an API key (a free or sandbox key works). Returns the complementary endpoints for the one you name, with their prices; for `/v1/risk/score` that is the full `/v1/entity/check`.

## Integration Example

An AI agent discovering and using Limitguard autonomously:

<CodeGroup>
  ```python Python theme={null}
  import httpx

  # Step 1: Discover capabilities
  listing = httpx.get("https://api.limitguard.ai/.well-known/x402.json").json()
  entity_check = next(e for e in listing["endpoints"] if e["path"] == "/v1/entity/check")

  # Step 2: Check price (the default fresh price, in USDC 6-decimal units)
  amount = int(entity_check["price_raw"])

  # Step 3: Build x402 payment and call
  from my_wallet import build_x402_payment
  x_payment = build_x402_payment(amount=amount)

  response = httpx.post(
      "https://api.limitguard.ai/v1/entity/check",
      headers={"X-PAYMENT": x_payment},
      json={"entity_name": "Acme Corp BV", "country": "NL"},
  )
  print(response.json()["trust_score"])  # 87
  ```

  ```javascript JavaScript theme={null}
  // Step 1: Discover capabilities
  const listing = await fetch("https://api.limitguard.ai/.well-known/x402.json")
    .then((r) => r.json());
  const entityCheck = listing.endpoints.find((e) => e.path === "/v1/entity/check");

  // Step 2: Check price (the default fresh price, in USDC 6-decimal units)
  const amount = Number(entityCheck.price_raw);

  // Step 3: Build x402 payment and call
  const xPayment = await buildX402Payment(amount);

  const response = await fetch("https://api.limitguard.ai/v1/entity/check", {
    method: "POST",
    headers: { "X-PAYMENT": xPayment, "Content-Type": "application/json" },
    body: JSON.stringify({ entity_name: "Acme Corp BV", country: "NL" }),
  });
  const result = await response.json();
  console.log(result.trust_score); // 87
  ```
</CodeGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.