---
title: "Deep Research APIs in 2026: Turnkey vs Build-Your-Own"
dek: "Deep research APIs split in 2026: turnkey costs $2–7/task or $5/1K searches; a build-your-own loop on Keirolabs runs $25–100 per 1,000 queries."
category: "comparisons"
tags: [deep-research, api-comparison, ai-agents, pricing, keirolabs]
author: "Dave"
published: 2026-08-17T12:00:00+00:00
updated: 2026-08-17T12:00:00+00:00
url: https://keirolabs.cloud/blogs/comparisons/deep-research-apis-2026-turnkey-vs-build-your-own
---
> **TL;DR** : Deep research is the workload that split the search API market in two in 2026: turnkey APIs cost $2–7 per task or $5 per 1,000 searches, while a build-your-own loop on Keirolabs runs $25–100 per 1,000 research queries, because the search primitive is 20x cheaper.
## Why is deep research the workload that split the search API market in two?
Deep research is the workload that turned a search API into a product, and in 2026 it split the market into two camps: turnkey APIs that run the whole loop for you at $2–7 per task or $5 per 1,000 searches, and raw search APIs you assemble into your own loop at $0.25 per 1K semantic search. The split is the biggest story in agentic AI.
Here's the thing nobody in this market wants to say out loud: deep research is the workload that turned the search API into a product, and the 2026 market just split in two. I've spent two years benchmarking these APIs from the bills, not the landing pages, and the gap between what the turnkey vendors charge and what the primitive actually costs is the biggest story in agentic AI. Everyone is comparing the wrong numbers. The headline price per task is a floor, not a bill. The real cost is the loop: the planning step, the searches, the read pass, the synthesis. And in 2026, that loop just got 20x cheaper for the people who build it themselves.
A single deep research task runs a planning step, a dozen or more searches, a read pass over the top results, and a synthesis step. In 2025 that whole pipeline shipped as one API call. In 2026 it is splitting into two camps: turnkey research APIs that run the loop for you, and raw search APIs you assemble into your own loop. The split is not cosmetic. A turnkey API is a product you consume. A search API is a component you compose. The first gives you a report and a bill. The second gives you a primitive and a cost curve you control.
This changes everything, and the argument is simple. The loop is becoming a developer problem, not a vendor product. OpenAI proved it on July 23, 2026, when it retired its dedicated deep research APIs. The company that defined the category now tells developers to build the loop themselves. When the market leader stops selling the loop, the loop stops being a product. What is left is the primitive, and the primitive is where the 20x gap lives.
## What do deep research APIs cost in 2026?
Deep research APIs in 2026 cost $1–7 per task on Gemini, $5 per 1,000 searches plus tokens on Perplexity, and nothing on OpenAI, which retired its dedicated research endpoints on July 23, 2026. A build-your-own loop on Keirolabs runs $25–100 per 1,000 research queries, because search costs $0.25 per 1K semantic and $0.10 per 1K SERP.
Deep research is the workload that made agent search a category. A chatbot can answer from memory. A research agent has to go find the answer, verify it, and show the sources. That loop is what users pay for, and it is why every major model vendor built a research product in 2025. The question in 2026 is whether you buy that loop or build it.
Here is the full 2026 price table, and it is the whole argument in one place.
The providers in this comparison.
| Provider | How you call it | Price | HLE | BrowseComp | SimpleQA |
| :--- | :--- | :--- | :--- | :--- | :--- |
| Gemini Deep Research | Interactions API, background/async | ~$1–3/task (preview), ~$3–7/task (max) | 54.6% | 85.9% | n/a |
| Perplexity Sonar Deep Research | One-call API | $2/1M input + $8/1M output + $5/1K searches | 21.1% | n/a | 93.9% |
| OpenAI | Responses API + web_search tool | No dedicated endpoint since 2026-07-23 | 26.6% | 51.5% | n/a |
| Claude | No dedicated research API | Build your own; web search tool $10/1K searches | n/a | n/a | n/a |
The table is the whole argument. **The turnkey options price the loop, and the loop is expensive.** Gemini charges per task, Perplexity charges per search, and OpenAI stopped selling the loop entirely. The build-your-own option prices only the primitive, which is where the 10–20x gap comes from.
Two pricing models are in play, and they are not interchangeable. "Per task" means you pay for the whole loop whether it ran 5 searches or 50. "Per search" means you pay for what the loop actually did, but the loop decides how many searches to run. Both are opaque from the caller's side. A search API you control is the only way to know what you are paying for before the bill arrives.
The split is not a marketing distinction. It is a cost structure distinction. A turnkey API bundles planning, search, reading, and synthesis into one price, and you cannot see the breakdown. A search API prices one operation, and you assemble the rest. The first is a product. The second is a component. Everything else in this post follows from that distinction.
## What changed in the deep research API landscape in 2026?
The big change is OpenAI. On July 23, 2026, OpenAI retired the dedicated o3-deep-research and o4-mini-deep-research APIs, so deep research now runs through the Responses API with the web_search tool. Gemini and Perplexity still sell turnkey research, but at very different prices: $1–7 per task versus $5 per 1,000 searches.
OpenAI's move is the one that matters. The company that defined the category with a single research endpoint now tells developers to build the loop themselves. The [deep research guide](https://developers.openai.com/api/docs/guides/deep-research) describes assembling planning, search, and synthesis through the [web_search tool](https://developers.openai.com/api/docs/guides/tools-web-search). The models behind it scored 26.6% on HLE at launch and 51.5% on BrowseComp, but you no longer call them as a dedicated research API. The retirement is a signal about where the market is going: the loop is becoming a developer problem, not a vendor product.
The practical effect is that OpenAI's deep research is now a build-your-own project with a vendor search tool. You keep the Responses API and the web_search tool, but you write the planning and synthesis steps. That is more code, but it also means you can swap the search tool for a cheaper one without changing the loop. That is the opening the cheap primitives walked through.
Gemini is the quality leader. [Google's deep research docs](https://ai.google.dev/gemini-api/docs/interactions/deep-research) show two agents: deep-research-preview at roughly $1–3 per task and deep-research-max at $3–7 per task, both running through the Interactions API in background mode and available through Vertex AI. Gemini posts the best numbers in the category at 54.6% HLE and 85.9% BrowseComp. You pay for that quality per task, and a task is minutes of compute. The async model means you fire a request, poll for the result, and wait.
Perplexity is the only major one-call API left. [Sonar Deep Research](https://docs.perplexity.ai/docs/sonar/models/sonar-deep-research) charges $2 per 1M input tokens, $8 per 1M output tokens, and $5 per 1,000 searches. It scores 93.9% on SimpleQA and 21.1% on HLE, and most runs finish in under 3 minutes. The trade-off is that you hand the whole retrieval loop to Perplexity and get back a report. You do not control which sources it retrieved, in what order, or how it weighted them.
Claude has no dedicated research API. Anthropic's answer is the same as OpenAI's post-retirement: build your own loop with the web search tool at $10 per 1,000 searches plus the Agent SDK. That puts Claude in the build-your-own camp by default. The [anycap.ai comparison](https://anycap.ai/page/en-US/ai/deep-research-apis-compared-2026) frames the same split from the agent side: consumer research tools are judged on report quality, while agent research is judged on programmatic access, structured output, and cost predictability.
## Why did OpenAI retire its dedicated deep research API?
OpenAI retired its dedicated deep research APIs because the loop became a developer problem. The o3-deep-research and o4-mini-deep-research endpoints shut down on July 23, 2026, and deep research now runs through the Responses API with the web_search tool, so developers assemble planning, search, and synthesis themselves.
Read the retirement the way a vendor reads it, not the way a press release reads it. OpenAI spent 2025 selling a single research endpoint that did everything. In 2026 it stopped. The company did not shut the endpoint down because research demand collapsed. It shut it down because the loop is no longer the product. The models are the product, and the loop is glue.
The [deep research guide](https://developers.openai.com/api/docs/guides/deep-research) is explicit about the new shape. You get the Responses API, you get the web_search tool, and you write the rest. The planning step is your code. The read pass is your code. The synthesis step is your code. OpenAI keeps the model and the search tool, and hands you the loop.
That is a huge tell about margins. A turnkey research API has to price in the compute for a multi-minute agent run, the search calls, the read pass, and the synthesis, all inside one opaque price. When you price that way, you either charge a lot or you lose money on the heavy tasks. OpenAI looked at that math and decided the loop was not worth selling. The primitive was worth selling. The loop was not.
The market read this correctly. If the largest model vendor in the world will not sell you the loop, the loop is not a durable product. It is a piece of engineering you own. And once you own it, you shop for the cheapest primitive that does not degrade your answers. That is the exact moment the search primitive became the battleground.
The cost of the OpenAI path is worth stating plainly. You keep the Responses API and the web_search tool, and you write the loop. The models score 26.6% on HLE and 51.5% on BrowseComp, which is behind Gemini on both. You are paying OpenAI's token rates for a loop you now maintain, on a search tool you cannot swap without rewriting your orchestration. The retirement did not make deep research cheaper. It made it your problem.
## How many searches does a deep research task actually run?
A deep research task runs 20 or more searches. Perplexity's own docs show a single task running 21 searches, and at $5 per 1,000 searches that is $0.105 in search fees per task before tokens. On Keirolabs at $0.25 per 1K semantic, the same 21 searches cost about $0.005.
The number that matters in this whole post is 21. That is how many searches a single deep research task ran in Perplexity's own documentation. Not 3, not 5. Twenty-one. And 21 is probably conservative, because a hard research question fans out: the planner splits it into sub-questions, each sub-question gets its own search, and the loop iterates until the evidence is solid.
Here is the primitive cost, and it is the whole argument in two bars.
Search primitive cost per 1,000 searches, 2026. The primitive is 20x cheaper on Keirolabs. Source: vendor pricing pages.
Now run the math on a real task. Perplexity charges $5 per 1,000 searches, so 21 searches cost $0.105 before a single token is billed. Keirolabs charges $0.25 per 1,000 semantic searches, so the same 21 searches cost about $0.005. **That is a 20x gap on the primitive, and it compounds across every search a research task runs.**
| Provider | Searches per task | Search cost per task | What else you pay |
| :--- | :--- | :--- | :--- |
| Perplexity Sonar Deep Research | 21 (from its docs) | ~$0.105 | $2/1M input + $8/1M output tokens |
| Gemini Deep Research | vendor decides | bundled into $1–7/task | nothing itemized |
| DIY on Keirolabs | you decide | ~$0.005 for 21 searches | your own LLM tokens |
The control point is the real difference. With a turnkey API, the loop decides how many searches to run and you pay for all of them. With a DIY loop, you decide. A question that is answerable in one search costs one search. A question that needs ten costs ten. The turnkey vendor has no incentive to stop early, because every search is revenue. You have every incentive to stop early, because every search is your money.
The fan-out is why the primitive price matters more than the task price. A research question is rarely one search. It is a tree: the planner asks three sub-questions, each sub-question needs two or three searches, and the loop re-searches when the first pass comes up thin. Twenty-one searches in Perplexity's docs is a single task, and a hard task runs more. Every search in that tree is billed at the primitive rate, so the primitive rate is the number that compounds. At $5 per 1K, a 30-search task costs $0.15 in search fees. At $0.25 per 1K, the same task costs $0.0075. The task price hides the tree. The primitive price exposes it.
## How do you build a deep research agent instead of buying one?
A build-your-own deep research agent is an agent loop plus a search API plus an LLM. The loop plans queries, searches, reads the top results, and synthesizes a cited report. On Keirolabs, search costs $0.25 per 1K semantic and $0.10 per 1K SERP, and one POST to /api/v2/search/content returns cited, cleaned content the LLM can read directly.
The recipe has four steps, and it is the same shape whether you use the Agent SDK, LangChain, or a plain while loop:
1. **Plan.** The LLM decomposes the question into sub-queries. "What changed in deep research pricing?" becomes "Gemini deep research pricing 2026", "Perplexity sonar deep research cost", "OpenAI deep research API shutdown".
2. **Search.** Each sub-query hits the search API. This is the step that used to be a turnkey API.
3. **Read.** The loop fetches the top results and feeds the cleaned content to the LLM.
4. **Synthesize.** The LLM writes the report with citations, and you keep the source list.
```python
import requests
# One search call inside a DIY deep-research loop.
# Returns cited, cleaned page content the LLM can read directly.
resp = requests.post(
"https://api.keirolabs.cloud/api/v2/search/content",
headers={"Authorization": "Bearer keiro_..."},
json={"query": "Gemini deep research pricing 2026", "mode": "medium", "maxResults": 5},
)
for r in resp.json()["results"]:
print(r["title"], r["url"], r.get("content", "")[:200])
```
The search call is the part that used to be a turnkey API. **Keirolabs returns cited, cleaned content in one request, so the loop does not need a browser or a scraper.** The LLM reads the content field directly and cites the URL that came with it. That is the whole build-your-own stack: a loop, a search call, and a model.
The loop is where the control lives. You decide how many searches a question deserves, when to stop, and what counts as a good source. A turnkey API makes those calls for you and hides them. If your product needs to show its work, or needs to stop early when the answer is clear, the DIY loop is the only shape that gives you that.
The orchestration layer is the part you already have. The Agent SDK, LangChain, and plain function calls all give you a loop that can call a tool and feed the result back to the model. The only piece that is specific to deep research is the search tool, and that is the piece Keirolabs prices at $0.25 per 1K semantic searches. Everything else is the same code you would write for any agent.
## How much does 1,000 research queries cost: turnkey vs build-your-own?
For 1,000 research queries, turnkey runs $800–1,000 on Perplexity and $1,000–7,000 on Gemini. A build-your-own loop on Keirolabs runs $25–100, because the search primitive is 20x cheaper: $0.25 per 1K semantic versus $5 per 1K searches, and the gap widens as volume grows.
This is the number that decides the market, so look at it on a log scale. The spread is too wide for a linear chart to show anything honest.
Cost per 1,000 research queries, 2026, log scale. The DIY bar is the small one. Source: vendor pricing pages.
| Approach | Cost per 1,000 research queries | What drives it |
| :--- | :--- | :--- |
| Perplexity Sonar Deep Research | ~$800–1,000 | $5/1K searches; a task runs ~20+ searches; tokens on top |
| Gemini Deep Research | ~$1,000–7,000 | $1–3/task (preview), $3–7/task (max) |
| DIY on Keirolabs | ~$25–100 | $0.25/1K semantic + $0.10/1K SERP; LLM tokens dominate |
The search primitive is where the gap lives. Perplexity charges $5 per 1,000 searches, and a single deep research task in its docs ran 21 searches. That is $0.105 in search fees per task before tokens. Keirolabs charges $0.25 per 1,000 semantic searches, so the same 21 searches cost about $0.005. **That is a 20x gap on the primitive, and it compounds across the 20+ searches a research task runs.**
The token side narrows the gap but does not close it. Perplexity bills input at $2/1M and output at $8/1M, with reasoning tokens at $3/1M. A DIY loop pays for the same LLM tokens on top of its search bill. Even so, the search component alone puts turnkey at $800–1,000 per 1,000 queries versus $25–100 for DIY, and the gap widens as volume grows.
The Gemini numbers are the clearest illustration of per-task pricing. At $1–3 per task for the preview agent, 1,000 tasks run $1,000–3,000. At $3–7 per task for the max agent, the same 1,000 tasks run $3,000–7,000. That is the price of the best HLE score in the category, and it is why per-task pricing only makes sense for low-volume, high-value research.
Call it 10–20x and you are still being conservative. The search primitive alone is 20x cheaper, and the per-task markup on top of it pushes the total gap past 10x for most workloads. The gap is not a rounding error or a promotional discount. It is the difference between pricing the loop and pricing the primitive, and it does not shrink as you scale.
## What are the hidden costs of a turnkey deep research API?
The hidden costs of a turnkey deep research API are token fees, rate-limit upgrades, and the audit you cannot get. Perplexity bills $2/1M input and $8/1M output on top of $5/1K searches, Gemini bundles everything into $1–7 per task, and neither lets you see which sources it used.
Every turnkey API has a second layer under the headline price, and the second layer is where the bill grows. Perplexity's $5 per 1,000 searches is the search line, but the answer tokens are billed separately at $2 per 1M input and $8 per 1M output. A research report is a long output, so the token line is not small. Gemini bundles everything into the per-task price, which means you cannot see how much of the $1–7 is search, how much is compute, and how much is margin.
Rate limits are the second hidden cost. A turnkey research task runs for minutes and holds a connection open the whole time. If your product runs research at volume, you hit the concurrency ceiling and you pay for the upgrade. The per-task price on the landing page assumes a polite trickle of requests, not a production queue.
The third hidden cost is the one nobody prices because it never appears on an invoice: the audit you cannot get. A turnkey API returns a report, not a source list you can verify. If a claim in the report is wrong, you cannot trace it to the page it came from, because the API does not tell you which pages it used. For a research product, that is not a feature gap. It is a liability.
The DIY loop has the same three costs, but they are visible. The token bill is your LLM bill, and you can see it. The rate limit is your own concurrency, and you can tune it. The audit is your source list, and you keep it. **The difference is not that the costs disappear when you build your own. The difference is that you can see them.**
That is the real argument for the primitive. A turnkey API is a black box with a price on the outside. A search API is a transparent component with a price you can model. When the price is 20x lower and the box is transparent, the choice is not close.
## What is the quality gap between turnkey and build-your-own?
The quality gap between turnkey and build-your-own is smaller than the cost gap. Gemini leads at 54.6% HLE and 85.9% BrowseComp, Perplexity leads SimpleQA at 93.9%, and a DIY loop on Keirolabs scores 78% on FinanceBench and 84% on SimpleQA, which is competitive for most production workloads.
Everyone assumes the turnkey vendors hold the quality advantage because they run the whole loop. The benchmark table says otherwise. The quality spread between the best and worst turnkey model is wider than the spread between turnkey and a well-built DIY loop.
Benchmark scores by provider, 2026. Gemini leads HLE and BrowseComp; Perplexity leads SimpleQA. Source: vendor benchmark reports.
| Benchmark | Gemini | OpenAI | Perplexity | Keirolabs (DIY) |
| :--- | :--- | :--- | :--- | :--- |
| HLE | 54.6% | 26.6% | 21.1% | n/a |
| BrowseComp | 85.9% | 51.5% | n/a | n/a |
| SimpleQA | n/a | n/a | 93.9% | 84% |
| FinanceBench | n/a | n/a | n/a | 78% |
HLE is the hard benchmark, and Gemini owns it at 54.6%. OpenAI's retired research models scored 26.6%, and Perplexity scored 21.1%. That is a real quality gap, and it is the reason Gemini can charge $1–7 per task. If your users need the deepest possible answer and the budget is there, that gap is worth paying for.
BrowseComp tells the same story. Gemini at 85.9% can find facts that require real browsing, and OpenAI at 51.5% is a distant second. This is the benchmark that measures whether a research agent can actually go find something on the open web, and it is where Gemini's per-task price earns its keep.
SimpleQA flips the ranking. Perplexity leads at 93.9%, which is the best factuality number in the group and matters for questions with a single correct answer. Keirolabs scores 84% on the same benchmark, which is competitive for a search primitive that costs $0.25 per 1K. **The quality gap between a $5/1K turnkey search and a $0.25/1K primitive is 10 points on SimpleQA, not 10x.**
FinanceBench is the financial-questions benchmark, and Keirolabs scores 78% on it. The reference points are GPT-4o plus vector RAG at about 19% and a GPT-4o oracle at about 85%. A DIY loop on Keirolabs lands at 78%, which is within striking distance of the oracle and far ahead of the standard RAG baseline. If your research loop touches financial documents, that number matters.
The quality conclusion is the one the turnkey vendors do not want you to see. The cost gap is 10–20x. The quality gap is single digits on most benchmarks. When the cost gap is two orders of magnitude and the quality gap is a few points, the build-your-own side wins for any workload that runs at volume.
Read the table the way a buyer reads it, not the way a vendor reads it. If your workload is a handful of deep questions a day, Gemini's HLE lead is worth $1–7 per task. If your workload is thousands of questions a month, the quality gap is a few points and the cost gap is two orders of magnitude. The benchmark that matters is the one that matches your traffic, and for most production workloads that is the cost benchmark, not the quality benchmark.
## When should you use a turnkey deep research API?
Use a turnkey API when you need a polished report fast and cost is secondary. Gemini leads quality at 54.6% HLE and 85.9% BrowseComp. Perplexity is the only one-call API and most runs finish under 3 minutes. Both hide the retrieval loop, which is the point: you get a report, not a pipeline.
Turnkey wins on time to first report. You send a prompt and get a cited document back, with no loop to build, no search calls to tune, and no read pass to debug. For a team shipping a research feature this quarter, that is a real advantage. The [anycap.ai comparison](https://anycap.ai/page/en-US/ai/deep-research-apis-compared-2026) makes the same point from the agent side: consumer research tools are judged on report quality, while agent research is judged on programmatic access and cost predictability.
Turnkey also wins on synthesis quality. Gemini's 54.6% HLE is the best in the category, and its 85.9% BrowseComp shows it can find facts that require real browsing. If your users need the deepest possible answer and the budget is there, that quality is worth paying for. Perplexity's 93.9% SimpleQA is the best factuality number in the group, which matters for questions with a single correct answer.
Turnkey loses on three things. First, cost: $1–7 per task or $5 per 1K searches does not survive high volume. Second, audit: the API decides what it retrieved and in what order, so you cannot show your work. Third, latency: a task takes minutes, not seconds. If your product needs a report in under a minute, or needs to prove where every claim came from, turnkey is the wrong shape.
Turnkey is the right call for a few specific jobs. A one-off board memo, a competitive teardown you run twice a quarter, a due-diligence pass on a single company: these are low-volume, high-value tasks where $1–7 per task is noise. The same is true for a demo or a prototype where the goal is a convincing report in an hour, not a production pipeline.
## When should you build your own deep research loop?
Build your own when you need audit trails, low latency, or volume. A turnkey task takes minutes and hides its sources. A DIY loop on Keirolabs returns cited results in about a second per search, so you can show your work, control the loop, and pay $0.25 per 1K semantic instead of $5 per 1K searches.
Audit trails are the strongest reason. A research agent that cites its sources is one users trust, and a DIY loop keeps the source list in your hands. Keirolabs returns structured citations with every result, so the final report can link each claim to the page it came from. That is the difference between a summary and a research product.
Latency is the second reason. A turnkey task runs for minutes because it does the whole loop server-side. A DIY loop can stop after one search if the answer is already clear, or fan out to ten searches when it is not. Sub-second search calls mean the loop spends its time on the LLM, not on waiting for a browser.
Cost is the third reason, and it is the one that decides at scale. **At 1,000 research queries per month, the gap is $800–1,000 turnkey versus $25–100 DIY.** At 100,000 queries, that is the difference between a rounding error and a line item. Keirolabs also scores 78% on FinanceBench, which matters if your research loop touches financial documents.
There is a fourth reason that is easy to miss: composability. A DIY loop is just code, so it can cache results, deduplicate queries, and reuse a search across multiple reports. A turnkey API is a black box that re-runs the whole loop every time. For a product that answers the same class of question repeatedly, the DIY loop gets cheaper with every run.
The DIY path is not free. You own the loop, which means you own its bugs: a sub-query that returns nothing, a source that is stale, a synthesis step that drifts off the evidence. You also pay for the LLM tokens yourself, and you need a model good enough to plan and synthesize. The trade is real, and it is the same trade every build-versus-buy decision makes. The difference here is that the build side is 10–20x cheaper to run, so the break-even point comes fast.
The break-even math is brutal for turnkey. Suppose a research task costs $3 on Gemini and your DIY loop costs $0.05 in search plus $0.20 in LLM tokens. The DIY loop breaks even on the first task and saves $2.75 on every task after that. At 1,000 tasks a month, that is $2,750 a month in savings, which pays for a lot of engineering time. The build-versus-buy decision usually has a long payback period. This one pays back on the first invoice.
## Where do you start with a build-your-own deep research agent?
Start with the free tier. Keirolabs gives you 1,000 queries per month at no cost, which is enough to build and test a research loop. The API base is api.keirolabs.cloud, and the content endpoint returns cited, cleaned content in one call.
The loop from the recipe above is about 40 lines of Python. Point it at the free tier, run it against a real question, and check whether the citations hold up. If they do, the paid tier scales the same way: $0.25 per 1K semantic search and $0.10 per 1K SERP, with no per-task markup.
One warning before you start: benchmark the citations, not just the answers. A research loop is only as good as the sources it finds, and the free tier is the right place to check that. Run the same question through a turnkey API and through your DIY loop, then compare the source lists. The gap in cost is easy to measure. The gap in quality is the thing you should measure first.
The 2026 decision is simple. **If you need a report and cost is secondary, buy turnkey. If you need volume, audit trails, or sub-minute latency, build the loop and pay for the primitive.** The free tier at [keirolabs.cloud](https://keirolabs.cloud) is the cheapest way to find out which camp you are in.
## What does the next 12 months look like for deep research APIs?
The next 12 months will make the split obvious. Turnkey research APIs will consolidate around high-value, low-volume work, while build-your-own loops on cheap search primitives will own the volume. The search primitive is 20x cheaper, and that gap does not shrink as you scale.
Here is what I know. The vendors that sell the loop are going to keep raising the price of the loop, because that is the only way per-task pricing survives. The vendors that sell the primitive are going to keep dropping the price of the primitive, because that is how you win the volume. Those two curves cross, and they cross fast.
OpenAI already voted. When the company that invented the category retires its dedicated research API and tells you to build the loop yourself, the market has spoken. The loop is a developer problem now. The primitive is the product. And the primitive is 20x cheaper than the loop it replaced.
In 12 months this will be obvious. The teams that built their own loops will be shipping research features at $25–100 per 1,000 queries while the teams that bought turnkey are paying $800–7,000 for the same volume. The first group will be able to afford 20x more research. The second group will be explaining the invoice. I know which group I want to be in, and I know which group wins.
The next 12 months will make this look obvious. Build the loop. Own the primitive. The free tier at [keirolabs.cloud](https://keirolabs.cloud) gives you 1,000 queries a month to start, and the [pricing page](https://keirolabs.cloud/pricing) shows the rest. The future is not the report you buy. The future is the loop you build.
## About the author
Dave builds AI agent and RAG pipelines and writes about the infrastructure behind them. He benchmarks search APIs from the bills, not the landing pages. You can follow his work on [GitHub](https://github.com/Manasbh).
## FAQ
### What is the best deep research API in 2026?
Gemini Deep Research leads quality at 54.6% HLE and 85.9% BrowseComp, but it costs $1–7 per task. Perplexity Sonar Deep Research is the only one-call API at $5 per 1,000 searches. For volume, a build-your-own loop on Keirolabs at $0.25/1K semantic search is 10–20x cheaper.
### Why did OpenAI shut down its deep research API?
OpenAI retired the dedicated o3-deep-research and o4-mini-deep-research APIs on July 23, 2026. Deep research now runs through the Responses API with the web_search tool, so developers assemble the loop themselves instead of calling a single research endpoint.
### How much does deep research cost?
Turnkey APIs run $1–7 per task on Gemini or $5 per 1,000 searches plus tokens on Perplexity. A build-your-own loop on Keirolabs costs roughly $25–100 per 1,000 research queries, with search at $0.25/1K semantic and $0.10/1K SERP.
### Can I build a deep research agent with Keirolabs?
Yes. Keirolabs returns cited, cleaned content from a single POST to /api/v2/search/content, so an agent loop can search, read, and synthesize without a browser or scraper. The free tier covers 1,000 queries per month.
