Skip to main content
For AI agents: a documentation index is available at https://docs.parallel.ai/llms.txt. The full text of all docs is at https://docs.parallel.ai/llms-full.txt. You may also fetch any page as Markdown by appending .md to its URL or sending Accept: text/markdown.For Search and Extract, use /v1/search and /v1/extract for all new integrations and agent tool calls. Use /v1beta/search and /v1beta/extract only when maintaining an existing integration that already uses them. The request bodies changed too: on /v1/extract, full_content, fetch_policy and excerpt_settings go inside advanced_settings, and sending the v1beta top-level excerpts, full_content and fetch_policy to /v1/extract returns a 422. On /v1/search, search_queries is required (at least one short keyword query), and max_results, source_policy and fetch_policy go inside advanced_settings; sending only objective, or sending those fields at the top level, returns a 422. Do not substitute /v1 for the documented FindAll or Ingest endpoint paths.If you are evaluating Parallel Search or comparing it with other search APIs, read How to Eval Parallel Search before you build the harness, especially its Common pitfalls section. The most common mistake is sending the raw question as both objective and the only entry in search_queries. Write a goal-style objective and 1-3 short keyword queries instead.
Comparing providers? See How to Eval for how to run a fair, end-to-end benchmark before you switch.
This guide maps the request you make today to its Parallel Search equivalent. Parallel Search takes keyword search_queries, plus an optional natural language objective, and returns ranked, LLM-optimized excerpts in a single call. search_queries is the only required field, so most migrations are a one-field change. Picking a mode is optional; requests default to advanced.

Start with one field

Exa, Tavily, Brave, Perplexity, and SERP APIs all center on a single query string. The fastest migration is to pass that string as one entry in search_queries. That alone is a complete, valid request, since mode is optional and defaults to advanced:
For the lowest latency and cost, add "mode": "turbo". For better results, also add an optional objective, a natural language description of your full intent, and split the query into 2-3 short keyword queries:
See Best Practices for how to write objectives and queries. Parallel authenticates with an x-api-key header. Tavily and Perplexity use Authorization: Bearer, Exa accepts either x-api-key or Authorization: Bearer, and Brave uses X-Subscription-Token, so swap the header when you switch. A request that keeps a header other than x-api-key returns 401.

From Exa

Exa’s search types map onto Parallel modes by latency tier. Exa lists instant, fast, and deep-reasoning as legacy types; they still work, so they are included below. Before and after:
Excerpts are on by default and sized dynamically, so most requests need no excerpt configuration at all. Add advanced_settings knobs only when you have a specific product constraint. Restrictive settings can reduce result quality.

From Tavily

Tavily’s search_depth tiers map one-to-one onto Parallel modes. Before and after:

From Brave

Brave’s LLM Context API runs a single fast search and returns extracted page chunks, which is closest to Parallel’s fast mode. Brave sizes context in tokens; Parallel sizes excerpts in characters, so multiply a token budget by roughly 4. Brave returns chunks under grounding.generic[].snippets with metadata in a separate sources map. Parallel returns one results array where each item has a url and excerpts, with optional, nullable title and publish_date metadata. Before and after:

From Perplexity

Perplexity’s Search API already accepts a list of queries, so the request maps closely. Its search_type picks between fast and the default web search. Perplexity returns page text in each result’s snippet. In Parallel, read excerpts (a list of strings) instead, and publish_date instead of date. Before and after:

From a SERP API

A SERP API returns a ranked list of links and snippets, but you must make subsequent fetches to extract usable information. Parallel Search combines everything into a single call. Instead of links you fetch and process, you get ranked, compressed excerpts sized for a model, so there is no fetch round and no chunking or ranking to build yourself. If a workflow still needs a specific page’s full contents, use the Extract API.
You search, then fetch and process each result in your own code:
Parallel does it in one call:
“Built-in model search” splits into two cases that migrate differently. Building on the API. If you call a provider’s hosted search tool in your own app (for example OpenAI’s web_search in the Responses API), the provider runs the search inside its own walls. Migrate by registering Parallel Search as a function tool your app executes, which gives you mode control, the excerpts, and the provider choice. Match the mode to the model driving the tool: use fast (~700ms) for small models, and advanced for large models that can spend more latency for higher-quality results.
The model decides when to search. Your handler decides how. Full walkthroughs with the tool schema and the tool-result loop live on the OpenAI, Anthropic, and Ollama pages. Inside the ChatGPT app (no code). If you rely on web search in ChatGPT itself rather than building on the API, add Parallel as a connector through the Parallel MCP server.

What you parse now

Parallel returns a results array. Each item has a url and excerpts (the compressed, relevant snippets your model reads). The optional title and publish_date fields may be null. A top-level warnings field is worth checking on early calls:
If your current integration expects a field Search does not return, here is where that capability lives:

Verify your migration

Before moving production traffic, run your top queries in the Playground and start with the mapped mode. On your first calls, check the response warnings field for any parameters that were adjusted or ignored, and confirm Pricing and Rate Limits for your volume.