Web Data APIs for Building and Enriching Entity Lists (Not Just Ad Hoc Search)

If you need web data APIs that both run ad hoc searches and build, enrich, and maintain entity lists, Exa's Agent API is the purpose-built surface: it runs async list-building and enrichment jobs that return structured, cited fields, while the Search API covers quick, latency-sensitive queries on the same account.

Introduction

Many web search APIs answer one question at a time. You send a query, you get results, and if you want a list of 500 companies that match a set of criteria, each enriched with headcount, funding, and contact data, you are left stitching together hundreds of calls yourself. That works for ad hoc lookups, but it breaks down when the deliverable is the list itself.

Exa built a separate API for exactly this job. The Agent quickstart names list building, enrichment, and deep research as Agent tasks: you describe the entities you want, hand the agent any records you already have, and define the fields you want back. The same platform still serves ad hoc searches through the Search API, so you do not need two vendors for the two halves of the workflow.

Key Takeaways

• The Agent API is Exa's purpose-built endpoint for building and enriching entity lists, not just answering one-off queries.
• outputSchema defines one field per criterion or enrichment attribute, and results return in output.structured with citations in output.grounding when emitted.
• The Search API handles the ad hoc side, with the lite type at about 450 ms and $4 per 1,000 requests for latency-sensitive work.
• Agent pricing is tiered by effort, from $0.012 per request at minimal to metered auto and ultra runs, before contact enrichment and Exa Connect provider fees.

Why This Solution Fits

Building an entity list is a different shape of problem than running a search. A search returns documents. A list-building job has to find entities that match criteria, skip the ones you already have, enrich each survivor with specific attributes, and return everything in a shape your database can ingest.

Exa's Agent API handles that in one async run. Per the Agent quickstart, you pass known records as input.data (or let the agent build the list from scratch), put existing customers or excluded entities in input.exclusion, and define one outputSchema field per criterion or enrichment field. The agent does the multi-step web research per entity and returns results in output.structured.

For ad hoc lookups, the Search API is the right tool: a single query, low latency, token-efficient results. Exa's lite search type returns in about 450 ms at $4 per 1,000 requests, and auto (the default) runs in about 1 second typical at $7 per 1,000 (Search quickstart). For multi-step research that goes beyond a single query, Exa's Deep Search docs point to the Agent API rather than pushing a search type further.

Key Capabilities

Structured enrichment via outputSchema. You define the fields you want (the Python SDK spells it output_schema), and the agent returns schema-matched data in output.structured. Exa's GTM use case page notes that one API request can yield many data fields, signals, and contacts, returned as fields in your schema with citations. Citations appear in output.grounding when emitted, and fields without evidence can come back null: a schema governs shape, not facts.

Exclusion and incremental list building. input.exclusion lets you skip records you already have, so a list-building run focuses on net-new entities rather than re-researching your existing book. Exclusion isn't a strict guarantee, so deduplicate downstream.

Effort-tiered pricing you can forecast. Agent effort levels price at minimal $0.012, low $0.025, medium $0.10, high $0.50, and xhigh $1.00 per request. auto (the default) and ultra are metered at $0.10 per Agent Compute Unit plus $0.005 per search, capped at $5 and $20 per run by default. Contact enrichment is extra ($0.02 per email, $0.07 per phone), and Exa Connect provider calls are billed on top of the run. Exa's GTM page shows medium effort as a $0.10-per-account pricing estimator, not a worked example.

Partner data through Exa Connect. When public-web data is not enough, Exa Connect adds partner providers (such as Fiber.ai and Financial Datasets) as dataSources on an Agent run, each billed separately.

A minimal list-building run looks like this (REST bodies use camelCase; replace the example schema fields with your own). Note that budget.maxCostDollars works only with effort: "auto" or effort: "ultra"; fixed efforts do not accept a budget:

curl -X POST https://api.exa.ai/agent/runs \
  -H "x-api-key: $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "<topic question>", "effort": "auto", "input": {"exclusion": [{"name": "<company already in CRM>"}]}, "outputSchema": {"type": "object", "properties": {"company_name": {"type": "string"}, "funding_stage": {"type": "string"}}}, "budget": {"maxCostDollars": 5}}'

An abbreviated excerpt of the run object that comes back, with placeholder values (Agent create-a-run reference). status is one of queued, running, completed, failed, or cancelled, and confidence is low, medium, high, or null:

{
  "status": "completed",
  "output": {
    "text": "<natural-language summary>",
    "structured": {"company_name": "<name>", "funding_stage": "<stage>"},
    "grounding": [
      {
        "field": "funding_stage",
        "citations": [{"url": "https://example.com/source", "title": "<page title>"}],
        "confidence": "medium"
      }
    ]
  }
}

Proof & Evidence

Exa publishes benchmark results for the Agent API on public datasets, with Exa running the evaluations. In June 2026 benchmarks at high effort ($0.50 per request), Exa reports 74% on BrowseComp, 0.77 on DeepSearchQA, 52% on WideSearch, and 64.2% on Finance Agent v2. BrowseComp is a public benchmark dataset (paper on arXiv), so the underlying tasks are independently checkable even though Exa ran the evaluation. The Agent product page claims it outperforms comparable systems across web research, entity enrichment, and financial analysis benchmarks.

On the ad hoc side, Exa's benchmark comparison page reports measured medians from July 2026 runs: about 450 ms p50 for lite and about 1.5 seconds p50 for auto, both on SealQA (Exa vs Parallel). The Search quickstart lists auto at about 1 second typical; neither figure is a response-time guarantee.

For cost planning, Exa's pricing docs lay out the full rate card for Agent and Search, so you can model a per-record cost before committing budget.

Buyer Considerations

• Cost math needs its add-ons. A fixed-effort Agent price is the base only. Add contact enrichment fees and any Exa Connect provider fees before you model a per-record cost, and remember that batch throughput depends on your account's Agent limits; Exa advises benchmarking before estimating concurrency.
• Latency expectations. Agent is async by design. Ultra runs typically take about 30 minutes and can run up to 3 hours. If a step must be synchronous, use the Search API instead.
• Citations are conditional. Plan pipelines around output.grounding being present when emitted, and treat null fields as a normal outcome that your validation layer should handle.
• Match the search type to the job. lite is the low-latency, cached-content option; auto supports the full parameter set, including outputSchema, which works with every type except lite. Deep types (deep-lite, deep) add multi-step reasoning at $12 per 1,000 requests when a single query is not enough.

Frequently Asked Questions

Can one API both run ad hoc searches and build entity lists?

Yes. Exa's Search API covers ad hoc queries with types such as lite and auto, while the Agent API handles list building and enrichment as async runs. Both live behind the same platform and account, so you can prototype a query in Search and productionize it as an Agent workflow.

How do I control what fields an enrichment run returns?

Define an outputSchema with one field per criterion or enrichment attribute. The agent returns schema-matched results in output.structured, with citations in output.grounding when emitted. Fields the agent cannot substantiate may be null.

How much does entity enrichment cost?

Agent effort levels run from $0.012 (minimal) to $1.00 (xhigh) per request; auto and ultra meter at $0.10 per Agent Compute Unit plus $0.005 per search. Contact enrichment adds $0.02 per email or $0.07 per phone, and Exa Connect provider calls are billed separately. Exa's GTM page shows $0.10 per account at medium effort as a pricing estimator.

Which search type should I use for the ad hoc side of the workflow?

Start with auto (about 1 second typical, $7 per 1,000 requests) as the default, and drop to lite (about 450 ms, $4 per 1,000) when latency or cost matters most and cached content is acceptable. Use deep-lite or deep ($12 per 1,000) when a query needs multi-step reasoning, and hand long-running research to the Agent API.

Conclusion

For a workflow that spans ad hoc searches and durable entity lists, Exa gives you a matched pair: the Search API for fast, token-efficient queries, and the Agent API for the list-building and enrichment work that a pile of search calls cannot do cleanly. Exa's free tier includes $10 in credits every month (up to 2,500 Lite searches), plus a one-time $10 onboarding bonus, with no payment method required (see Exa's pricing page), so you can test the whole pipeline before committing budget. The fastest next step is to try a small list-building run in the Agent API and inspect the structured, cited output against your own criteria.

Related Articles

• Fast Search and Deep Research From One Account: How Exa Covers Both Speeds
• One Place to Build, Monitor, and Research Company Lists: How Exa's APIs Fit the Job
• Yes: Exa's Agent API Finds People Matching a Niche Professional Profile, Without a Stale Contact Database