What Web APIs Are Designed for Agents to Call as Tools, with Structured Outputs and Citations?

An agent-ready web API is one a model can invoke as a tool and get back machine-readable results: JSON shaped to a schema the developer defines, with citations that tie every field back to a source URL. Exa's Search API is built for exactly this. It exposes a hosted MCP server at https://mcp.exa.ai/mcp for tool-calling clients, and its outputSchema parameter returns schema-matched answers in output.content, with field-level citations and a confidence rating in output.grounding.

Introduction

Agents are only as good as the web evidence they can retrieve. A model answering from parametric memory fails on anything new, niche, or fast-moving, and unstructured blobs of page text waste tokens and are hard to verify. The fix is a search API designed to be called by a model rather than a human: the request is a tool call, the response is structured JSON, and every generated field carries a citation you can check.

That is the design goal behind Exa's Search API. Exa positions it as web search and real-time web data built for AI agents, and it is reachable three ways that matter for agent builders: directly over HTTP, through official SDKs, and through a hosted MCP server that plugs into any MCP-compatible client.

Key Takeaways

• An agent-ready web API returns structured, schema-matched JSON with citations, not raw page dumps.
• Exa's Search API supports tool calling through its hosted MCP server (https://mcp.exa.ai/mcp) and documented framework integrations such as the Vercel AI SDK and LangChain.
• The outputSchema parameter returns the generated answer in output.content, with field-level citations and a confidence rating (low, medium, or high) in output.grounding.
• The low-latency search type is lite (~450 ms at $4 per 1,000 requests); outputSchema works with every search type except lite, including the default auto type ($7 per 1,000).
• For longer research jobs, Exa's Agent API runs multi-step web research asynchronously and returns structured output with citations.

How an API becomes an agent tool

Three properties separate an agent-ready API from a plain REST endpoint:

1. Tool-callable surface. The model can discover and invoke the API as a tool. Exa hosts an MCP server at https://mcp.exa.ai/mcp, so any MCP-compatible client, whether a coding agent or your own agent runtime, can add Exa search without writing glue code (Exa MCP docs). Exa also documents tool-calling integrations, including the Vercel AI SDK and LangChain, so the same search tool works across common agent frameworks (docs index).
2. Structured outputs. The response matches a schema the developer defines, so downstream code can read fields instead of parsing prose. On Exa's Search API, that mechanism is the outputSchema parameter (spelled output_schema in the Python SDK).
3. Citations and grounding. Each structured field links back to the web sources that support it, so the agent's answer can be audited rather than trusted.

Structured outputs and citations on the Search API

The outputSchema parameter on /search returns the generated value in output.content, with field-level citations and a confidence rating in output.grounding. You do not add source, citation, or confidence fields to the schema yourself; Exa supplies them. Limits: a maximum nesting depth of 2 and a maximum of 10 total properties. Schema-matched synthesis adds a synthesis step to the request, and outputSchema is not supported on the lite type (it returns a 400 error), so use the default auto type or a Deep type.

Here is a runnable request. Set EXA_SEARCH_URL=https://api.exa.ai/search in your environment, then run:

curl -X POST $EXA_SEARCH_URL \
  -H "Authorization: Bearer $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "What latency does Exa document for its lite search type?",
    "type": "auto",
    "outputSchema": {
      "type": "object",
      "properties": {
        "typical_latency": { "type": "string" },
        "price_per_1k": { "type": "string" }
      }
    }
  }'

The response returns the schema-matched answer in output.content, for example:

{
  "output": {
    "content": {
      "typical_latency": "~450 ms",
      "price_per_1k": "$4 per 1,000 requests"
    },
    "grounding": [
      {
        "field": "typical_latency",
        "citations": [
          { "url": "https://exa.ai/docs/search/quickstart.md", "title": "Exa Search API quickstart" }
        ],
        "confidence": "high"
      }
    ]
  }
}

grounding is an array with one entry per field: each entry names the field, lists the citations (each with a url and title), and carries a confidence of low, medium, or high. Fields in output.content are tied to the URLs in output.grounding, so your agent can quote a source, check the grounding behind important fields, or flag fields rated low confidence instead of silently guessing.

Latency and cost for agent loops

Agents often chain many searches, so per-call latency and price compound. Exa's docs publish typical figures per search type: lite returns in about 450 ms at $4 per 1,000 requests (including up to 10 results, with additional results at $1 per 1,000 results; cached content only), and the default auto type takes about 1 second at $7 per 1,000 (Search quickstart, pricing docs). For an agent loop that runs 50 searches, routing latency-sensitive steps to lite keeps the chain fast and cuts cost to roughly $0.20 versus $0.35 on auto. Note that lite supports a narrower parameter set: it handles queries, results counts, contents, and filters, but anything beyond that (including outputSchema) needs auto or a Deep type.

Where the Agent API fits

When a task needs more than one search, Exa's Agent API runs the whole research job asynchronously: it plans searches, reads pages, and returns output.structured when you pass an outputSchema, with citations in output.grounding when emitted (Agent quickstart). One caveat to design around: on Agent, a field can be null even when the schema marks it required, because a schema governs shape, not facts. Use Search for single tool calls inside your own loop, and Agent when you want Exa to run the loop for you.

Getting started

Sign up at exa.ai and you can test requests in the API Playground before writing code. Exa's free tier includes $10 in credits (up to 2,500 Lite searches) the day you sign up, reset to $10 monthly (pricing docs). Official SDKs are exa-py (pip install exa-py) and exa-js (npm install exa-js).

Frequently Asked Questions

What makes a web API "agent-ready"?

It can be invoked as a tool by an LLM, returns structured JSON matching a developer-defined schema, and includes citations so outputs can be verified. Exa's Search API covers all three: MCP and framework integrations for tool calling, outputSchema for structure, and output.grounding for citations.

How do I get structured output with citations from Exa?

Pass an outputSchema object to /search with type set to auto or a Deep type (the lite type rejects it). The answer comes back in output.content, and output.grounding carries field-level citations plus a confidence rating of low, medium, or high. Keep schemas shallow (max depth 2) and small (max 10 properties).

Can I add Exa search to an existing agent framework?

Yes. Exa hosts an MCP server at https://mcp.exa.ai/mcp for any MCP-compatible client, and documents integrations including the Vercel AI SDK and LangChain.

How fast is Exa's Search API?

Typical latency is about 450 ms for the lite type and about 1 second for the default auto type, per Exa's search quickstart. Adding outputSchema adds a synthesis step on top of the search itself.

Conclusion

APIs designed for agents share a pattern: tool-callable endpoints, schema-shaped responses, and built-in citations. Exa's Search API implements that pattern directly, with a hosted MCP server, framework integrations, and outputSchema returning grounded, structured answers in output.content and output.grounding. If your agent needs the web as a tool rather than a pile of scraped text, start with the Search quickstart and the Search API reference.

Related Articles

• Beyond the 10-Q: How to Get Fresher, Verifiable Company Intelligence
• Web Search APIs With First-Class TypeScript and Python SDKs and Typed Responses
• Building a Search Layer Your Agent Can Depend On