Connect Exa to Claude: Monitor the Web & Enrich Data with Websets

If you need to connect Exa to Claude to automate deep web research, company profiling, or asynchronous data enrichment via Websets, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Exa's native REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Exa to ChatGPT or explore our broader architectural overview on connecting Exa to AI Agents.

Giving a Large Language Model (LLM) read and write access to a powerful neural search engine like Exa presents unique engineering challenges. Exa is not a standard CRUD application. You are dealing with massive, unstructured HTML payloads, semantic search algorithms, and long-running asynchronous batch tasks that require deliberate polling. Every time an API schema shifts or a new extraction method is introduced, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Exa, connect it natively to Claude, and execute complex research workflows using natural language.

The Engineering Reality of the Exa API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools via JSON-RPC, the reality of implementing it against Exa's specific API architecture requires careful handling of payload sizes, asynchronous states, and rate limit architectures.

If you decide to build a custom MCP server for Exa, you own the entire API lifecycle. Here are the specific challenges you will face:

Massive Payload Management and Context Blowouts Unlike a CRM that returns a few kilobytes of structured JSON, Exa's Contents API returns dense arrays of parsed HTML, highlights, and summaries. If you allow an LLM to request the full text of 20 URLs at once without strict pagination or filtering, you will instantly blow out the model's context window. A robust MCP implementation needs to map Exa's extraction parameters carefully so the LLM knows it can request shorter summaries or specific highlights before committing to pulling full document text.

Asynchronous Websets and Agent Runs Exa's Websets feature allows you to perform batch searches, verify results against criteria, and enrich data asynchronously. This means your MCP server cannot simply make a synchronous HTTP request and return the final data. You have to expose a set of tools that allow the LLM to create a Webset, extract the id, and subsequently poll the status endpoint until the run reaches a terminal state (completed or failed). If the tools do not explicitly describe this polling requirement in their schema descriptions, the LLM will hallucinate results or fail to complete the workflow.

Strict Rate Limits and Normalization Exa enforces strict rate limits depending on your team's API tier, particularly for intensive operations like deep reasoning searches or massive content extractions. Truto normalizes Exa's upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset).

Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Exa API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. The caller (in this case, the Claude MCP client) is responsible for reading these headers and executing its own retry logic with exponential backoff. Do not rely on the integration layer to absorb Exa's rate limits.

sequenceDiagram
  participant Claude as Claude Desktop
  participant Server as Managed MCP Server
  participant Truto as Truto Proxy Layer
  participant Exa as Exa Native API

  Claude->>Server: tools/call (create_a_exa_webset)
  Server->>Truto: Validate Token & Schema
  Truto->>Exa: POST /websets
  Exa-->>Truto: 200 OK (id: ws_123, status: queued)
  Truto-->>Server: Standardized Response
  Server-->>Claude: Result: ws_123
  Note over Claude: Claude initiates polling loop
  Claude->>Server: tools/call (get_single_exa_webset_by_id)
  Server->>Truto: Proxy Request
  Truto->>Exa: GET /websets/ws_123
  Exa-->>Truto: 429 Too Many Requests
  Truto-->>Server: 429 (ratelimit-reset: 60)
  Server-->>Claude: Error: 429. Model must backoff.

Instead of building this infrastructure from scratch, you can rely on Truto. Truto dynamically generates tool definitions directly from Exa's resource documentation, providing Claude with perfectly formatted JSON schemas for query parameters, body payloads, and asynchronous polling instructions.

How to Generate an Exa MCP Server with Truto

Truto derives MCP tools dynamically from the integration's documented resources. When you connect an Exa account, Truto evaluates the available endpoints and generates a secure MCP server URL. You can provision this server through the Truto interface or programmatically via the API.

Method 1: Via the Truto UI

For administrators and internal AI agent deployments, generating the server via the dashboard is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Exa account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure your server settings. You can restrict the server to specific HTTP methods (e.g., read only) or apply tag filters (e.g., search, monitoring).
5. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For teams building multi-tenant SaaS applications where each of your users needs their own instance of Claude connected to their own Exa account, you must generate the MCP server programmatically.

Make an authenticated POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/admin/integrated-accounts/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Exa Web Intelligence Server",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The API provisions a secure, hashed token in a globally distributed key-value store and returns the connection details:

{
  "id": "mcp_9a8b7c6d",
  "name": "Exa Web Intelligence Server",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/f8e7d6c5b4a3..."
}

Connecting the Exa MCP Server to Claude

Once you possess the secure MCP server URL, you must instruct Claude to communicate with it. Because Truto MCP servers operate over standard HTTP using Server-Sent Events (SSE), connection is straightforward.

Method A: Via the Claude UI (or ChatGPT)

If you are using Anthropic's web-based Claude interface (or ChatGPT with custom connectors), you can add the server directly via the settings menu:

1. Open Claude and navigate to Settings -> Integrations (or in ChatGPT: Settings -> Apps -> Advanced settings).
2. Click Add MCP Server (or Add custom connector).
3. Provide a recognizable name, such as "Exa Intelligence Agent".
4. Paste your Truto MCP Server URL into the target field.
5. Click Add. Claude will perform an initialization handshake, request the list of available Exa tools, and make them immediately accessible in your chat session.

Method B: Via Manual Configuration File (Claude Desktop)

If you are running Claude Desktop locally or configuring a headless agent environment like Cursor or LangGraph, you configure the connection via JSON.

Locate your claude_desktop_config.json file. On macOS, this resides at ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, it is located at %APPDATA%\Claude\claude_desktop_config.json.

Add your Truto server to the mcpServers object. We recommend using the official @modelcontextprotocol/server-sse npx package to handle the SSE transport:

{
  "mcpServers": {
    "exa-intelligence": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/f8e7d6c5b4a3..."
      ]
    }
  }
}

Restart Claude Desktop. The application will read the configuration, connect to Truto, and pull down the complete Exa tool definitions.

Hero Tools for Exa

When Claude connects to the Truto MCP server, it receives a dynamic list of tools compiled from Exa's API documentation. Here are the highest-leverage operations your AI agent can perform.

create_a_exa_search

Search the Exa web index and extract content from matching pages. This is the core semantic search tool. It supports natural language queries and allows you to dictate exactly what content to return (text, highlights, summaries).

Contextual Note: Use this tool when you need broad intelligence gathering. Be precise with your contents parameter to avoid overwhelming the model with irrelevant boilerplate HTML.

"Perform a semantic search on Exa for 'technical architecture of vector databases in 2026'. Return the top 5 URLs and include a brief summary and the top 3 highlights from each page."

create_a_exa_answer

Submit a question to Exa's answer endpoint, which performs an Exa search and uses an underlying LLM to generate either a direct factual answer or a detailed summary with citations.

Contextual Note: This tool is incredibly efficient for open-ended queries where you want Exa to do the heavy lifting of synthesis before returning the result to Claude. It guarantees cited sources.

"Use the Exa answer tool to find out the latest regulatory changes regarding AI compliance in the European Union. Provide a detailed summary with citations linking to the source material."

exa_companies_search

Search Exa's index of over 50 million professional companies using natural language queries. Filter by industry, funding stage, headcount, geography, and technology stack.

Contextual Note: This tool returns structured entities rather than unstructured web text. It is ideal for lead generation, account intelligence, and competitive landscaping.

"Search the Exa companies index for series B startups in the cybersecurity space based in London. Extract their headquarters location, latest funding data, and estimated web traffic."

create_a_exa_content

Extract clean, LLM-ready content from one or more specific URLs using the Exa Contents API.

Contextual Note: Use this tool when you already know the URLs you want to parse (perhaps gathered from a previous search or provided by the user). It strips out noise and returns pristine markdown.

"Take these three documentation URLs from Stripe, Twilio, and SendGrid, and extract their full text using the Exa contents tool. Summarize the differences in their webhook authentication mechanisms."

create_a_exa_webset

Create a new Exa Webset that asynchronously searches, verifies, and enriches web results against specified criteria.

Contextual Note: Websets are asynchronous. Instruct your agent that it must create the webset, note the id, trigger a search within that webset, and then poll get_single_exa_webset_by_id until the status changes.

"Create a new Exa webset to track news articles mentioning 'solid state battery breakthroughs'. Once created, initiate a search within the webset for 50 items and check its status."

create_a_exa_monitor

Create a new Exa monitor that runs recurring searches on a schedule and delivers results to a webhook endpoint with automatic deduplication.

Contextual Note: The webhookSecret is only returned once at creation time. Ensure Claude is instructed to log or store this secret securely if your downstream systems require signature verification.

"Set up a recurring Exa monitor that searches for mentions of our brand name every 24 hours. Route the results to our internal webhook at https://api.ourcompany.com/alerts/exa."

For the complete inventory of Exa endpoints, precise JSON Schema requirements, and specific parameter constraints, refer to the Exa integration page.

Workflows in Action

Individual tools are powerful, but the true value of an MCP server emerges when an LLM chains these tools together to execute multi-step workflows. Because Truto exposes Exa's raw capabilities through a flat input namespace, Claude can orchestrate complex logic seamlessly.

Scenario 1: Deep Industry Research and Company Profiling

An operations analyst wants to build a dossier on emerging competitors in a specific software vertical without spending hours manually Googling and reading landing pages.

"Find 5 fast-growing Series A startups in the data observability space using the Exa companies search. For each company found, extract the exact text from their primary landing page to determine how they differentiate their architecture from Datadog."

Step-by-step execution:

1. Claude calls exa_companies_search with a natural language query describing the target market.
2. Exa returns a list of 5 structured company entities, including their primary URLs.
3. Claude parses the URLs from the response and calls create_a_exa_content, passing the 5 URLs in an array.
4. Exa returns the clean, extracted text from all 5 landing pages.
5. Claude processes the combined text within its own context window, drafting a comparative analysis report for the user.

Scenario 2: Asynchronous Data Enrichment via Websets

A marketing team needs to build a highly verified list of target accounts that meet strict, nuanced criteria that simple keyword searches cannot satisfy.

"Create an Exa Webset to find B2B SaaS companies that specifically mention SOC 2 compliance on their security pages. Initiate a search for 20 results. Once the webset has completed processing, set up an enrichment task to extract the name of their Chief Information Security Officer (CISO)."

Step-by-step execution:

1. Claude calls create_a_exa_webset to initialize the batch container.
2. Claude calls create_a_exa_webset_search using the returned webset_id, providing the specific search criteria and limiting the count to 20.
3. Claude enters a loop, periodically calling get_single_exa_webset_by_id to check the progress.
4. Once the webset status is marked completed, Claude calls create_a_exa_webset_enrichment, providing instructions for the underlying agent to extract the CISO's name from each verified item.
5. Claude polls get_single_exa_webset_enrichment_by_id until finished, then presents the final enriched tabular data to the user.

Security and Access Control

Providing an AI agent with access to an enterprise search and extraction engine requires strict governance. Truto MCP servers are not black boxes; they offer granular security controls at the infrastructure level.

• Method Filtering: When creating the MCP server, you can restrict the token to specific operational classes via config.methods. Passing ["read"] ensures the server only exposes safe retrieval endpoints like get and list, entirely preventing the agent from creating webhooks or deleting active monitors.
• Tag Filtering: Integrations in Truto map endpoints to logical groups using tool_tags. You can configure an MCP server to only expose tools tagged with search or companies, isolating access to specific domains.
• Require API Token Authentication: By default, possession of the MCP server URL is sufficient to execute tools. Setting require_api_token_auth: true adds a secondary validation layer. The MCP client must provide a valid Truto API token in the Authorization header, preventing unauthorized execution even if the URL leaks.
• Automatic Expiration: You can provision ephemeral access by setting an expires_at timestamp. Truto enforces this at the distributed storage level, scheduling an automatic alarm that permanently purges the token and its associated capabilities once the deadline is reached.

Move Beyond Boilerplate Integration Code

Connecting Exa to Claude using a custom MCP server requires writing and maintaining hundreds of lines of boilerplate code to handle OAuth, pagination logic, API versioning, and massive JSON schemas.

Truto abstracts this entire layer. By relying on documentation-driven, dynamically generated tools, you ensure your AI agents always have access to the latest Exa capabilities without draining your engineering team's resources.