---
title: "Tavily API guide (2026): API key, pricing, search parameters and MCP"
category: "guides"
url: https://keirolabs.cloud/blog/tavily-api-guide-2026
---

## The 60-second version

**Tavily is a web search API built for AI agents: you send a query, it returns ranked results with clean text snippets, and optionally a short answer or the full page content.** It is one of the most widely used search tools in LangChain, LlamaIndex and agent frameworks, and in 2026 it became part of Nebius, the AI cloud company, which announced the acquisition on February 10, 2026 ([Morgan Lewis](https://www.morganlewis.com/news/2026/02/morgan-lewis-advises-nebius-on-acquisition-of-agentic-search-provider-tavily)). The product and brand are unchanged.

- **Get a key:** sign up at Tavily, copy the key from the dashboard (it starts with `tvly-`). The free Researcher plan gives **1,000 credits a month, no card required**.
- **Price:** **$0.008 per credit pay as you go.** A basic search is 1 credit ($8 per 1,000), an advanced search is 2 ($16 per 1,000). Monthly plans bring the credit down to $0.005 at $500 a month.
- **Endpoints:** Search, Extract, Map, Crawl and Research, all on one key.
- **Limits:** 100 requests a minute on a development key, 1,000 on a production key.

**For most agents, start with `search_depth: "basic"` and only turn on `include_raw_content` when the model needs the whole page.** Those two settings decide most of your bill and latency.

## What is Tavily?

**Tavily is a search engine API whose output is written for language models rather than people.** A normal search engine returns a page of links. Tavily returns a JSON list of results, each with a title, URL, a relevance score and a snippet of the page chosen to answer the query, so an agent can read it without fetching and cleaning HTML.

It sits between two other kinds of tool:

| Tool type | What you get | Example |
|---|---|---|
| SERP API | Google's or Bing's result page as JSON: positions, titles, short snippets | SerpAPI, Serper |
| **AI search API** | **Ranked results with LLM-ready content, optional answer** | **Tavily, Exa, Keirolabs, Parallel** |
| Answer API | A written answer with citations | Perplexity Sonar |

Tavily also offers an answer (`include_answer`) and full page content (`include_raw_content`), so one call can cover all three needs. That flexibility is why agent frameworks adopted it early. We compare it against the field in [best web search API for AI agents](/blog/web-search-apis-for-agents-2026).

## How do you get a Tavily API key?

1. **Sign up** at [app.tavily.com](https://app.tavily.com) with Google, GitHub or email.
2. **Copy the default key** from the dashboard. It starts with `tvly-`.
3. **Store it as `TAVILY_API_KEY`** in your environment. Never put it in front-end code.
4. **For production traffic, create a production key.** Production keys need a paid plan or pay as you go enabled, and raise your limit from 100 to 1,000 requests a minute ([rate limits](https://docs.tavily.com/documentation/rate-limits)).

The free plan covers 1,000 credits a month, which is 1,000 basic searches or 500 advanced ones. That is enough to build and test an agent; it is not enough to run one for real users.

## How do you make your first Tavily search?

**Install `tavily-python`, create a `TavilyClient` and call `search`.** The JavaScript SDK works the same way.

```python
# pip install tavily-python
import os
from tavily import TavilyClient

client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

resp = client.search(
    "What did Nebius announce about Tavily?",
    search_depth="basic",   # 1 credit; "advanced" costs 2
    max_results=5,
    include_answer=True,    # adds a short LLM answer
)
print(resp["answer"])
for r in resp["results"]:
    print(round(r["score"], 2), r["title"], r["url"])
```

Or call the REST endpoint directly:

```bash
curl -X POST https://api.tavily.com/search \
  -H "Authorization: Bearer $TAVILY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "latest Brave Search API pricing", "max_results": 5}'
```

Each result has `title`, `url`, `content` (the snippet), `score`, and, when you ask for them, `raw_content`, `published_date`, `images` and `favicon`. The response also carries `response_time` and a `request_id` for support tickets ([Search reference](https://docs.tavily.com/documentation/api-reference/endpoint/search)).

## Which Tavily search parameters matter?

The Search endpoint has more than twenty parameters. These are the ones that change results, cost or speed:

| Parameter | Values | What it does |
|---|---|---|
| `search_depth` | `basic` (default), `advanced`, `fast`, `ultra-fast` | Advanced finds better passages and costs 2 credits; the others cost 1 |
| `max_results` | 0 to 20, default 10 | Results returned |
| `topic` | `general`, `news`, `finance` | News adds publish dates automatically |
| `time_range` | `day`, `week`, `month`, `year` | Freshness filter; `start_date` and `end_date` also work |
| `include_answer` | `false`, `basic`, `advanced` | Adds an LLM answer to the response |
| `include_raw_content` | `false`, `markdown`, `text` | Adds the full page; slower, and many more tokens |
| `include_domains` / `exclude_domains` | up to 300 / 150 domains | Restrict or block sources |
| `include_domains_mode` | `restrict` (default), `prefer` | Prefer boosts your domains without hiding the rest of the web |
| `chunks_per_source` | 1 to 3, default 3 | Snippets per result, about 500 characters each (800 on advanced) |
| `country` | e.g. `united states` | Boosts one country's results (general topic only) |
| `auto_parameters` | `true` / `false` | Tavily picks settings from the query; it may switch to advanced and charge 2 credits |

**Watch `auto_parameters`.** It is convenient, but it can quietly upgrade a search to advanced depth and double its cost. If you budget per query, set `search_depth` yourself.

## How much does the Tavily API cost?

**Everything is billed in credits: $0.008 each pay as you go, falling to $0.005 on the $500 Growth plan.** Rates from Tavily's [credits page](https://docs.tavily.com/documentation/api-credits), checked October 15, 2026:

| Plan | Price | Credits a month | Price per credit | Basic searches per 1,000 |
|---|---|---|---|---|
| Researcher | Free | 1,000 | n/a | free up to 1,000 |
| Pay as you go | usage | any | $0.008 | $8.00 |
| Project | $30/mo | 4,000 | $0.0075 | $7.50 |
| Bootstrap | $100/mo | 15,000 | $0.0067 | $6.70 |
| Startup | $220/mo | 38,000 | $0.0058 | $5.80 |
| Growth | $500/mo | 100,000 | $0.005 | $5.00 |

What each endpoint costs in credits:

| Endpoint | Credits | Pay-as-you-go cost |
|---|---|---|
| Search, basic / fast / ultra-fast | 1 per request | $8 per 1,000 |
| Search, advanced | 2 per request | $16 per 1,000 |
| Extract, basic | 1 per 5 successful URLs | $1.60 per 1,000 URLs |
| Extract, advanced | 2 per 5 successful URLs | $3.20 per 1,000 URLs |
| Map | 1 per 10 pages (2 with instructions) | $0.80 per 1,000 pages |
| Crawl | Map cost plus Extract cost | depends on pages |
| Research, mini | 4 to 110 per request | $0.03 to $0.88 |
| Research, pro | 15 to 250 per request | $0.12 to $2.00 |

**Failed extractions are free:** Extract and Map bill only successful URLs. The full breakdown, including what the $5 figure people quote really requires, is in our [Tavily pricing analysis](/blog/tavily-search-api-pricing-per-1000-requests-2026).

## What are Extract, Map, Crawl and Research?

- **Extract** takes a batch of URLs you already have and returns their content as markdown or text. Use it after a search, on the two or three results your agent actually needs.
- **Map** walks a site and returns its URLs, like a generated sitemap. Useful before crawling docs.
- **Crawl** is Map plus Extract: it follows links from a starting URL and returns page content, with natural-language instructions to focus it. It is limited to 100 requests a minute on every key.
- **Research** runs a multi-step research task and returns a report. You create a task, then poll for the result. Creating tasks is limited to 20 a minute.

**The cheapest reliable pattern is search, then extract only what you need:** a basic search (1 credit) plus extracting two URLs (under half a credit) costs less than an advanced search with raw content on every result, and puts fewer tokens in front of your model.

## How do you use Tavily with MCP, Claude Code or Cursor?

**Tavily runs a hosted MCP server at `https://mcp.tavily.com/mcp/`, so agents can search without any code.** In Claude Code, one command adds it and opens a browser sign-in:

```bash
claude mcp add tavily-remote-mcp --transport http https://mcp.tavily.com/mcp/
```

For Cursor and other clients, pass the key in the URL (`https://mcp.tavily.com/mcp/?tavilyApiKey=<your-key>`) or run the local package with `npx -y tavily-mcp@latest`. The server exposes search and extract as tools ([Tavily MCP docs](https://docs.tavily.com/documentation/mcp)). We compare it against nine other servers in [the best MCP servers for web search](/blog/best-mcp-servers-web-search-scraping-2026).

## What are the Tavily API rate limits?

| Key or endpoint | Limit |
|---|---|
| Development key, general endpoints | 100 requests per minute |
| Production key, general endpoints | 1,000 requests per minute |
| Crawl (any key) | 100 requests per minute |
| Research task creation (any key) | 20 requests per minute |
| Usage endpoint | 10 requests per 10 minutes |

Over the limit you get HTTP 429, sometimes with a `Retry-After` header; wait that many seconds before retrying. Two other codes are worth handling: **432** means your plan's credits are used up, **433** means you hit your pay-as-you-go spending limit. Neither will clear by retrying. Limits for ten other providers are in [search API rate limits](/blog/search-api-rate-limits-2026).

## What are the best Tavily alternatives?

| Alternative | Price per 1,000 searches | Free allowance | Choose it when |
|---|---|---|---|
| **Keirolabs** | from $0.25 (search), $0.10 (Google SERP) | 1,250 credits/month, no card | You want search, extraction and answers cheaper on one key |
| **Exa** | $4 (instant), $7 (auto) | $10 credit/month | You want semantic, find-similar search |
| **Brave Search API** | $5 | $5 credit/month | You want an independent index at high throughput |
| **Perplexity Search API** | $5 | none | You want Perplexity's ranking without the answer |
| **Parallel** | from $1 | free hosted MCP | You want dense excerpts at the lowest per-call price |

Prices from each vendor's site or our dated breakdowns: [Exa](/blog/exa-api-pricing-2026), [Brave](/blog/brave-search-api-pricing-2026), [Parallel](/blog/parallel-search-api-pricing-2026), [Keirolabs](https://keirolabs.cloud/pricing). Disclosure: Keirolabs is ours. For a head-to-head, see [Exa vs Tavily](/blog/exa-vs-tavily); for the full list, [Tavily alternatives](/blog/tavily-alternatives-2026).

## Common Tavily mistakes

- **Leaving `include_raw_content` on by default.** Full pages for ten results can be tens of thousands of tokens. Ask for raw content only on the results you will use, or use Extract.
- **Turning on `auto_parameters` without a budget check.** It can switch to advanced depth at 2 credits.
- **Shipping on a development key.** It caps at 100 requests a minute; production keys need a paid plan or pay as you go.
- **Retrying 432 and 433 errors.** They mean credits or spend limits, not a temporary overload.
- **Comparing the $5 Growth rate with other vendors' pay-as-you-go rates.** Tavily's pay-as-you-go rate is $8 per 1,000.

## The short answer

Tavily is the easiest AI search API to start with: a free key in a minute, a one-line Python call, and results your model can read directly. It costs $8 per 1,000 basic searches pay as you go, $5 on the $500 Growth plan, and its Extract, Map, Crawl and Research endpoints cover the rest of an agent's web work on the same credits. If price at volume is your main concern, compare it with the alternatives above before you commit.