Parallel Task API or Hyperresearch: which one fits the job

Use Parallel’s Task API when you need research inside a product: thousands of calls, structured JSON back, and a price per task between half a cent and $2.40. Use Hyperresearch when one long report is the deliverable: $9 or $49 flat, built from 20 to 200 sources, with its cited claims checked against the pages they cite before it ships. On ten DRACO tasks graded with the same judge, Hyperresearch Deep scored 77.7 and Parallel’s Ultra reports 61.5.

Parallel sells web research as a set of APIs: Search, Extract, Task, Responses, FindAll and Monitor. Its Task API is the one that does deep research, and its pro and ultra processors are the ones Parallel tunes for it. Hyperresearch sells one thing, a research run, through a REST API, a remote MCP server and a web console. This page compares the Task API with Hyperresearch, using Parallel’s own docs and pricing pages as of October 2026.

The Task API and Hyperresearch side by side

Parallel’s cells come from its pricing docs, processor guide, deep research guide, research basis docs, Task MCP docs, data connectors and rate limits, as of October 2026. Hyperresearch’s source counts, lengths and times are the targets the pipeline gates on, not guarantees.

Parallel prices deep research per task, from $0.30 to $2.40

The Task API charges once per completed run, set by the processor you pick. Parallel’s pricing docs list nine processors, from lite at $5 per 1,000 runs to ultra8x at $2,400 per 1,000. Parallel’s pages differ on lite’s latency: the pricing docs give 10 to 60 seconds, the processor guide 10 seconds to 2 minutes. The four ultra processors are the deep research tier:

• ultra: $300 per 1,000, so $0.30 a run. Labelled “Advanced multi-source deep research”, 5 to 25 minutes.
• ultra2x: $0.60 a run, 5 to 50 minutes.
• ultra4x: $1.20 a run, 5 to 90 minutes.
• ultra8x: $2.40 a run, “The most difficult deep research”, 5 minutes to 2 hours.

Price does not depend on how many output fields you ask for, and Parallel says failed runs are not billed. Its marketing pricing page adds “up to $80 at signup + $5 in free credits per month”. The cost is known before the call, which is not true of token-metered research APIs such as Perplexity’s or Gemini’s.

Hyperresearch is also priced before the call. The 202 response that creates a run carries price_cents, 900 or 4900, before any work starts, and runs that fail on our side are refunded automatically. A Deep run at $49 costs about 163 times an ultra task and about 20 times an ultra8x task. A Light run at $9 costs 30 times an ultra task. Those ratios are the honest starting point: the two products are not priced for the same job.

Speed and volume favour Parallel

Parallel’s processor guide publishes measured execution times from production. For ultra, the median is 4 minutes and the 90th percentile 10 minutes; for ultra8x, 6.5 and 11 minutes. Those figures exclude time spent in the queue, which Parallel says grows when you submit a large burst. The deep research guide gives an outer bound: “Deep Research can take up to 45 minutes to complete.”

Volume is where the gap is widest. The default Task API limit is 2,000 task runs created per minute, and polling for status does not count against it. A task group runs one task spec over many inputs, which is how you enrich a list of companies or a spreadsheet of products row by row.

A Hyperresearch run takes about 30 to 40 minutes for Light and about 3 to 5 hours for Deep. Those are targets, not measurements. It is not built for thousands of runs an hour, and a spreadsheet of 5,000 rows is a Parallel job.

A Parallel deep research task returns JSON or a cited Markdown report

Deep research on the Task API takes a plain-language question of up to about 15,000 characters and returns one of three shapes:

• Auto schema, the default for pro and ultra: the processor decides the JSON structure. Parallel’s own sample response, a market report on the US HVAC industry, came back with 124 content fields and 610 citations.
• Text schema: “a markdown report with in-line citations”, steerable through a description field that can set length or focus.
• Your own JSON schema: the fields you need, filled from the web.

The structured modes are the Task API’s real strength. If your code needs a table of competitors, a funding date or a list of executives with titles, a typed JSON object is far more useful than a report you then have to parse. Hyperresearch returns a report and a claims table, not your schema.

Parallel does not publish how many sources a deep research task reads or how long its text report runs. Hyperresearch publishes targets for both: about 20 to 50 sources and 2,500 to 4,000 words for Light; about 150 to 200 sources for Deep, with a report sized to the question of up to about 9,000 words.

Parallel rates confidence per field; Hyperresearch checks each citation

Every Task API result carries a research basis. Per Parallel’s basis docs, each output field, and each element of a top-level list field, gets its citations (a URL and the excerpts used), a reasoning note, and a confidence rating of high, medium or low. Low means “limited or conflicting evidence, or information from less reliable sources”. For a JSON output that is granular: you can route every low-confidence field to a person and accept the rest.

Two limits matter if the output is a report someone will be held to. First, a text output gets a single basis entry for the whole report, so the confidence rating applies to the report, not to each sentence. Second, the basis records where the processor found information. The docs describe no separate step that reads each citation back against the sentence citing it and returns a verdict. Parallel says multiple citations “often” indicate stronger evidence, which is a heuristic, not a check.

A Hyperresearch run does that check before the report ships. Every cited figure is read against the source it cites, and what does not hold is corrected in one guarded revision. A Deep report adds a verification receipt with a verdict for each checked citation (supported, partially supported, unsupported or wrong source) and the passage from the source that the verdict rests on. A cited paper that has been retracted, or a quotation that does not appear in its source, stops the report from shipping.

A receipt is a record of checks, not a promise that every claim is true. A supported verdict means the source says what the sentence says, not that the source is right. Hyperresearch has not published a measured error rate for its own checker, and a Light report gets the claim check but no receipt.

If you want to keep Parallel and add the check, the same code is sold on its own. The citation verification API takes a document and its sources, including the raw output of another vendor’s deep research, and returns a verdict for every citation.

On ten DRACO tasks, Hyperresearch scored 77.7 and Parallel Ultra 61.5

We graded Hyperresearch Deep runs and other research agents on the same 10 tasks from DRACO, a deep research benchmark from Perplexity and Harvard, one task from each of its 10 domains, in October 2026. Every report was scored by the same judge, GPT-5.2 at the paper’s settings. Parallel was graded once, from its DRACO reports published in Valyu’s benchmark repository; we did not run Parallel ourselves. Our reports were graded twice and the two grades averaged.

Hyperresearch scored higher on all 10 tasks. The widest gaps are on the Medicine task, 72.2 against 29.4, the Finance task, 70.8 against 45.8, and the UX design task, 74.2 against 50.5. Parallel came closest on the Personalized assistant task, 64.1 against 62.6, and the Law task, 90.6 against 85.0.

Read the result with its limits. These are 10 of DRACO’s 100 tasks. Parallel’s reports have one grade each, and two grades of the same report can differ by up to about 9 points. The reports we graded are labelled ultra8x, Parallel’s top processor at $2.40 a task, against a $49 Deep run. And this is our measurement, not an official leaderboard. How we tested has every task score and the other systems we graded, including Claude Research (Opus) at 73.0, or see a full Deep report.

Parallel reaches licensed and logged-in data; Hyperresearch reads public pages

Parallel can take a task beyond the open web. Its data connectors come in three forms: Index Partners that Parallel has licensed, used by default on eligible runs; free and pay-per-use connectors you name per run, with PubMed and ClinicalTrials.gov listed as free; and your own licensed providers attached as remote MCP servers, up to 10 per task. Through the Browser Use integration, a task can reach pages behind a login in a browser profile you control.

A Hyperresearch run reads public pages, logged out, and never solves CAPTCHAs. It recovers open-access full text for papers with a DOI, searches scholarly indexes and SEC filings, and when a page will not load it can stop and ask you to supply the document. It does not read paywalled articles, private company databases or anything behind a login. Sources lists what a run can and cannot read.

Agents can call both over MCP

Parallel’s Task MCP server at https://task-mcp.parallel.ai/mcp has four tools: createDeepResearch, createTaskGroup, getStatus and getResultMarkdown. It authenticates with OAuth or an API key as a bearer token. Parallel notes that an agent has to ask for the result in a further turn once the task is done.

The Hyperresearch MCP server at https://mcp.hyperresearch.ai/mcp uses the same start, check and fetch pattern, for the same reason: a Deep run takes hours, longer than any client will hold a tool call open. start_run returns an id and the price at once. Long-running MCP tools explains the design, and the server also exposes vault search, so an agent can query what earlier runs read without starting a new one.

Where Parallel is the better choice

• Volume. 2,000 task runs a minute by default, and a task group API built for running one spec over thousands of rows. Hyperresearch is not built for that.
• Price per call. $0.30 for an ultra deep research task. If the output feeds another system rather than a reader, that is the right price.
• Speed. A median of 4 minutes for ultra. If an agent or a user is waiting, Parallel’s processor guide points to its Responses API, at 30 to 60 seconds for its deepest setting.
• Structured output. Your JSON schema, filled and cited field by field, with a confidence rating on each. Hyperresearch returns a report.
• Data beyond the public web. Licensed partners, pay-per-use connectors, your own MCP servers and logged-in pages through Browser Use.
• Procurement. Parallel lists SOC 2 for every API, and zero data retention, data protection agreements and single sign-on on its enterprise plan.
• A wider toolkit. Search, Extract, FindAll and Monitor sit beside the Task API under one key.

Where Hyperresearch is the better choice

Hyperresearch fits when the report is the thing you hand over and someone will ask where each number came from. A Deep run splits the question into 3 to 5 research chapters, maps where its sources contradict each other, sends investigators down the disputed points, and plans the report section by section before one writer writes it in one pass from all of the evidence, followed by the claim check and the receipt. How it works lists every stage.

The second reason is what stays behind. Every source a run reads is kept in your workspace vault with its provenance, and the next run in the same project searches the vault before the web. Parallel’s interaction ids carry context into a follow-up call, and Parallel Memory, rolling out now, saves past Task, Monitor and FindAll runs so your agent can search them through Parallel’s CLI or agent skill; Parallel says memory is never used automatically and that personal memory never changes API results, and applications opt in per request with a memory_scope_key. A Hyperresearch vault keeps the source corpus itself, full-text searchable, and exports it as plain Markdown.

The third is the scored result. On the ten DRACO tasks above, the gap was 16.2 points on the mean, and it was widest on the medicine and finance tasks, where a wrong number costs the most.

Moving a Parallel deep research call to Hyperresearch

If each call needs a short structured answer, stay on Parallel; drop to pro or core if ultra is more than the job needs. If you were running ultra with a text schema to produce long reports and then checking the citations by hand, the Parallel call looks like this:

curl -X POST https://api.parallel.ai/v1/tasks/runs \
  -H "x-api-key: $PARALLEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "<question>",
    "processor": "ultra",
    "task_spec": { "output_schema": { "type": "text" } }
  }'

The Hyperresearch call is the same shape:

curl -X POST https://api.hyperresearch.ai/v1/runs \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "<question>",
    "tier": "premier",
    "webhook_url": "https://example.com/hooks/hyperresearch"
  }'

input becomes query, which takes up to 4,000 characters, shorter than Parallel’s 15,000, so move long background into levers.domain_notes. processor becomes tier: light or premier, which is Deep on the wire. There is no output schema; every run returns the report as Markdown. Parallel’s webhook becomes webhook_url, or poll GET /v1/runs/{id}. In place of previous_interaction_id, pass a project_id so that follow-up runs reuse the sources earlier runs in the project collected. When the run is done, GET /v1/runs/{id}/result returns the report, the full source list, every page tried and not kept, the claims table and, on Deep, the verification receipt. Your first Deep run is free once you add a card. Pricing has the full numbers, and migrating off the OpenAI deep research API walks through every request field.

How this comparison was made

Every Parallel figure on this page comes from Parallel’s own docs and pricing pages, read logged out on October 12, 2026, re-read on October 22, 2026, and linked where it is used. Where Parallel’s pages disagree, as they do on some processor time ranges, we used the pricing docs and say so. Where Parallel does not publish a figure, the table says “Not published”. The DRACO scores are our grading of Hyperresearch Deep runs and of Parallel’s DRACO reports from Valyu’s benchmark repository with the same judge in October 2026, described on how we tested; we did not run Parallel on a question of our own, and ten tasks do not settle which writes the better report on yours. Hyperresearch figures are the targets the pipeline gates on, as printed on pricing. Parallel changes its processors and prices over time, so we will re-check these numbers by the end of 2026 and change the date at the top when we do.