Deep Research APIs Compared: Exa, Parallel, Perplexity, Valyu and You.com

A deep research API takes an open-ended question, plans its own retrieval path, reads tens to hundreds of pages, and returns a cited report or a filled JSON schema. Calling it a slower search API understates the difference: the billing unit changes, the failure mode changes, and a call that runs for five minutes cannot sit inside a chat turn, so the product shape changes too.

As of July 2026, five vendors sell this as a first-class product: Exa, Parallel, Perplexity, Valyu and You.com. The short version of the comparison is that Parallel publishes the most legible price and latency ladder (nine Task processor tiers, $5 to $2,400 per 1,000 requests), Perplexity is the least work to adopt if you already call an OpenAI-compatible endpoint, Valyu and You.com both sell a single effort dial that maps to a price, and Exa is the cheapest way to bolt research onto an index you are already querying.

The category has one public rubric benchmark, DRACO, and it needs an asterisk: it was published by Perplexity researchers and built from de-identified Perplexity Deep Research traffic, and the most widely circulated scoreboard on it was published by Valyu, one of the vendors it ranks. Both facts are worth carrying before you let any number from it decide a contract. This guide covers what these endpoints do, what the benchmark measured, how the four pricing shapes differ, and how to run a one-week trial without building an eval harness first. For the single-shot search tier that sits underneath all of this, see AI Search APIs Compared.

What a deep research API does that a search API does not

A search API executes the query you gave it. You control the phrasing, you get results in hundreds of milliseconds, and you pay per request regardless of how hard the question was. That is the entire contract, and it is why the tier is priced at roughly $5 per 1,000 calls across Tavily, Linkup, You.com Web Search and Parallel Search.

A deep research API takes the query as an objective and decides the searches itself. The endpoint runs a loop: propose sub-questions, search, fetch and read pages, notice a gap, search again, then write. Three consequences follow.

The unit of work is variable, so the price is too. A question answerable from two pages and one that requires forty both enter through the same endpoint. Vendors handle this either by making you pre-commit to an effort tier (Parallel, You.com, Valyu) or by metering the work after the fact (Perplexity's token streams, Exa's per-run billing). Neither shape lets you predict a monthly bill from request volume alone.

Latency moves from milliseconds to minutes. Parallel's published Task latencies run from 10 to 60 seconds at lite up to five minutes to two hours at ultra8x. Valyu's published modes span 1 to 8 minutes (Fast) through up to three hours (Max). This is the fact that reshapes your product, not the accuracy scores.

Citations become part of the contract. All five vendors return sources attached to the output, and several return structured JSON with per-field citations rather than a prose blob. If you are building anything where a user will ask "where did this come from," that attachment is most of what you are buying.

Four jobs buyers keep conflating

Most confused vendor evaluations in this category come from comparing products that do different jobs. There are four, and only the third and fourth are deep research.

Search. One query in, ranked results out, sub-second. Tavily, Linkup, Exa's fast modes, You.com Web Search, Parallel's Search API at $1 to $5 per 1,000. You write the query and do the synthesis.

Agentic search. Your agent runs the loop, calling a search API repeatedly and deciding what to do next. The intelligence lives in your code. Cost is your search calls plus your model tokens, and you can inspect every step. This is what most teams have already built and often what they should keep.

Research task. You hand over the loop. The vendor plans, searches, reads and returns a result, usually against a JSON schema you supply. Parallel's Task API and Exa's research endpoint sit here. The output is data, not prose.

Report generation. Same loop, but the deliverable is a long-form document with structure, narrative and citations, graded by a human reading it. Perplexity Sonar Deep Research, Valyu DeepResearch and You.com's higher research_effort tiers are shaped for this.

The distinction matters commercially, because DRACO grades job four (presentation quality and objectivity are two of its four dimensions) while most engineering teams buying a "deep research API" want job three. A vendor can be excellent at producing a well-structured 3,000-word memo and mediocre at filling twelve fields of a schema correctly, and the public benchmark will not tell you which.

Vendor by vendor

All figures are the vendors' own published rates as of July 2026 and change often. Confirm on the pricing page before you budget.

Parallel is the easiest of the five to reason about, because effort, price and latency sit on one axis with nine notches and all of it is on the public pricing page. The -fast variants are the underrated part: lite-fast is documented at the same $5 per 1,000 as lite with latency cut to 10 to 20 seconds. Parallel also publishes its own comparative claims against Exa and Perplexity on BrowseComp, which is a vendor-run evaluation and should be read as marketing until reproduced.

Perplexity Sonar Deep Research wins on adoption cost. It is a model name on a chat-completions endpoint, so the integration is a string change rather than a job queue. The bill is the complication: four separate token streams plus a per-search fee, and reasoning tokens dominate. Published breakdowns of real calls put single queries in the $0.41 to $1.32 range, with one worked example attributing roughly $1.02 of a $1.32 call to reasoning tokens alone. You cannot cap that from the request side the way you cap a Parallel processor tier.

You.com sells the same idea as Parallel with one dial instead of nine notches. research_effort runs lite, standard, deep, exhaustive, frontier, and the price scales with it from $12 per 1,000 calls to north of $2,000. New accounts get $100 in credits, the largest published trial balance of the five, and enough to run a real evaluation rather than a demo.

Valyu is the newest entrant and the one that made the loudest accuracy claim, backed by its own published DRACO run. Its distinguishing feature is source coverage: alongside the open web it indexes arXiv, PubMed and SEC filings, which matters if your research questions are scientific or financial and the general web is mostly noise for them. It is asynchronous by default with webhook callbacks, which is the correct default for a product whose Standard mode runs 5 to 20 minutes.

Exa is the odd one out, because research is a mode on an index rather than a separate product. Its async task API returns a researchId you poll and will fill a JSON schema you provide. Exa's reference documentation carries a deprecation note pointing the standalone /research/v1 endpoint toward /search with type: "deep-reasoning", so check which surface is current before you write against it. Exa also sells Websets, a list-building product that is easy to mistake for deep research and is not the same job: Websets finds and enriches many entities matching criteria, while a research task answers one question deeply. For the index side of Exa, see Exa vs Perplexity Sonar.

What the DRACO benchmark measured, who published it, and what it leaves out

DRACO (Deep Research Accuracy, Completeness, and Objectivity) is the only public rubric benchmark aimed squarely at this tier. It is a set of complex, open-ended research tasks spanning 10 domains and drawing on sources from 40 countries, graded against task-specific rubrics on four dimensions: factual accuracy, breadth and depth of analysis, presentation quality, and citation quality. The dataset is public on Hugging Face at perplexity-ai/draco.

Two facts about its provenance belong next to any score you quote from it. First, the paper (arXiv 2602.11685) is authored by Perplexity researchers, and the tasks are sampled from a de-identified dataset of Perplexity Deep Research requests. That is a defensible way to build a realistic benchmark and also means the task distribution is the distribution of one vendor's users. Second, the scoreboard most often cited from DRACO is the one Valyu published in its DeepResearch launch post, in which Valyu places first.

Valyu's published run reports Valyu DeepResearch at 72.7%, Perplexity Deep Research at 70.5%, Claude Opus 4.6 at 59.8%, Gemini Deep Research at 59.0%, OpenAI o3 at 52.1%, Parallel's ultra8x at 51.2% and Exa's deep reasoning mode at 25.9%. Read as reported by Valyu on a benchmark published by Perplexity, that table is still useful: the roughly 20-point gap between the top two and the next cluster is large enough to survive some grader noise, and it directly contradicts Parallel's own positioning, in which its Task ladder outperforms Perplexity and Exa on BrowseComp. Two vendors, two benchmarks, two opposite orderings. That is the state of public evidence in this category.

What DRACO does not measure is most of what will decide your build. It grades report quality, not schema-fill accuracy, so it says little about job three. It has nothing to say about latency, cost per task, tail behavior on the 5% of queries that hang, or refusal rates on paywalled and blocked sources. And it is a static set: no public benchmark currently tests whether a research endpoint degrades when the target sites start blocking AI crawlers. For the wider benchmark picture in this space, see web extraction benchmarks.

Asynchrony: polling, webhooks, and what a five-minute task does to your product

The expensive part of adopting this category sits outside the API call: the call outlives the HTTP request that started it.

A search API fits inside a request handler. A research task does not. The moment you adopt one, you need a job record with a vendor task ID and a status, a way to advance that record, and a way to show a user something while they wait. Three shapes are in use across these vendors, and they are not equivalent.

Poll. Submit, get an ID, ask again on an interval. Exa's research task works this way, returning a researchId you check. Polling is the simplest thing that works and it stays simple until concurrency rises, at which point you are paying for and rate-limiting a lot of empty status checks.

Webhook. Submit with a callback URL, get called when the work is done. Valyu documents this and Parallel's Task API supports it. This is the right default above a minute of runtime, and the cost is that you now need a publicly reachable endpoint, signature verification, and idempotent handling of the retries the vendor will send.

Blocking call. Perplexity's Sonar Deep Research runs on a chat-completions endpoint, so the naive integration is a single long request. This is why it is the easiest to adopt and the easiest to get wrong: a multi-minute HTTP request will meet a load-balancer or serverless timeout somewhere in your stack, and you will discover which one in production.

The product consequence is larger than the engineering one. A research endpoint pushes you toward a "we will notify you" interaction: a queued report, an email, a row in a table that fills in later. If your product cannot absorb that shape, the only tiers open to you are the fastest ones, and at that point compare them against an agentic search loop you control, because the gap in both cost and quality narrows sharply at the low-effort end.

Pricing shapes: per request, per token, per source touched

Four incompatible units are in play, which is why direct price comparison in this category is mostly an illusion.

Per request with a pre-declared tier. Parallel and You.com. You choose the processor or effort level, and you know the exact price before the call runs. This is the only shape that lets you enforce a budget from the request side, and it is the reason Parallel's ladder is worth studying even if you buy elsewhere.

Per token across several streams. Perplexity. Input, output, citation and reasoning tokens are billed separately at $2, $8, $2 and $3 per million respectively, with searches added at $5 per 1,000. Reasoning is both the largest line and the one you have least control over, which makes forecasting hard until you have a few hundred real calls of history.

Per run, metered after the fact. Exa's research tasks, and the general direction of agent-style billing where compute units, search calls and enrichments are each priced. Cheapest at the low end, least predictable at the high end.

Flat CPM by mode. Valyu's published Fast, Standard and Heavy tiers at $100, $500 and $2,500 per 1,000, with Max quoted per request. This reads expensive against a $5-per-1,000 search API and is the honest number for the work involved: a 20-minute research run is not competing with a search call.

The comparison to run is cost per accepted answer, not cost per call. A $2.40 ultra8x task that lands is cheaper than four $0.30 tasks you throw away. Nobody publishes that ratio for you, which is the whole argument for a trial.

When a research endpoint is the wrong tool

Buy a research API when the plan is the hard part. Skip it when it is not.

If your question decomposes the same way every time, you are paying a model to rediscover a routine you could write once. A loop over a $5-per-1,000 search API plus your own extraction step will typically cost an order of magnitude less, and it is inspectable: when the answer is wrong you can see which query returned junk and fix that query. A research endpoint's failure mode is a plausible report with a bad source buried in it, which is considerably harder to catch.

Three other cases favor building the loop yourself. When you need the intermediate steps in your product (showing a user which sources were considered, not just which were cited). When you have proprietary corpora that must be searched alongside the web, since none of these endpoints will query your internal index. And when your volume is high and your questions are narrow, where the per-call premium compounds into a real line item. The general framing is in Build vs Buy: getting web data into your AI pipeline, and the retrieval-side options are in RAG data sources.

The inverse also holds. Do not build the loop when per-claim citation quality is a product requirement, when the questions are genuinely open-ended, or when you would need to maintain crawling and anti-bot handling to reach the sources. That is the work these vendors are actually selling.

How to trial one in a week without building a full harness

You do not need an eval framework to make this decision. You need twenty questions and a spreadsheet.

Day 1: write 20 real queries. Pull them from your product's actual traffic or your users' actual questions. Include at least three you already know the correct answer to, and at least three you expect to fail (paywalled sources, very recent events, non-English sources). A benchmark built from your own distribution beats any published leaderboard for this purpose.

Day 2: pick three vendors and two tiers each. One cheap tier and one expensive tier from each vendor, six configurations. You.com's $100 in credits and the free tiers across the category cover most of this without a purchase order.

Days 3 to 4: run everything, log everything. Record wall-clock time, the billed cost of each call, and the raw output. Cost per call is the number vendors publish; cost per call at your actual query complexity is the number you need.

Day 5: grade blind on three axes. Was the answer correct, were the citations real and load-bearing, and did the output match the schema or structure you asked for. Strip vendor names before grading. Half an hour per configuration is enough to separate the field.

Day 6: compute cost per accepted answer. Total spend divided by outputs you would ship. This regularly inverts the ranking you get from the price list, and it is the only number worth taking to a procurement conversation.

Day 7: check the tail. Re-run your five hardest queries five times each. Variance and hangs at the top tiers are what break production, and no published benchmark reports them.

The short version

The public evidence about which of these is best is currently two vendor-published benchmarks pointing in opposite directions, so pick on shape before you pick on score. If you need a schema filled with cited fields and a price you can predict per call, Parallel's Task ladder is the clearest instrument. If you want a cited long-form report with the least integration work, Perplexity Sonar Deep Research is a model-name change, at the cost of a bill you cannot cap from the request side. If your sources are academic or financial, Valyu's arXiv, PubMed and SEC coverage is a genuine differentiator. If you want one dial and a large trial budget, You.com. If you are already on an index and want research as a mode rather than a product, Exa.

Then check whether you need any of them. The honest answer for a large share of teams is an agentic loop over a $5-per-1,000 search API, which you can see into and fix. For that comparison, start with how to choose a search API for your AI product or browse the full AI search APIs category.