Most AI agents don’t fail because the model is weak. They fail because the context is stale, bloated, or missing.
Search is where that context comes from. In 2026, Tavily is the default answer for many teams: it ships in LangChain tutorials, has an MCP server, and the free tier takes minutes to set up.
If you’re:
- building AI agents,
- designing RAG pipelines,
- or picking a real-time search layer for an LLM product,
this Tavily review is for you. I ran 10 agent-style queries through the Tavily search API on October 13, 2026, compared it head-to-head with Exa, and pushed its extraction endpoint against pages it was never designed to read.
Here’s what came back.
TL;DR and Fact Sheet
Bottom line of this Tavily review: Tavily is a fast, well-integrated AI agent search API for the public web. Advanced search returns noticeably fresher results than basic search at twice the credit cost. Publish dates are the most consistent in the category. It stops at logins, persistent sessions and heavily protected pages.
| Tavily (October 2026) | |
|---|---|
| What it is | Search and extraction API built for LLMs and agents |
| Ownership | Acquired by Nebius (announced February 2026); the dashboard now reads “Tavily by Nebius” |
| Endpoints | Search, Extract, Map, Crawl, Research |
| Output | Structured JSON results + optional page content as Markdown or plain text |
| Search depths | ultra-fast, fast, basic (1 credit), advanced (2 credits) |
| Free tier | 1,000 credits/month, no card |
| Paid plans | From $30/month (4,000 credits) to $500/month (100,000 credits) |
| Pay as you go | $0.008 per credit |
| MCP | Remote server at mcp.tavily.com + local tavily-mcp package |
| Frameworks | Official langchain-tavily package |
| Logged-in pages | Not supported |
What Is Tavily and Who Is It For?
Tavily is a search engine whose only user is a program. Instead of ten blue links, the Tavily search API returns ranked results with a relevance score, a content snippet, an optional publish date and, if you ask for it, the cleaned content of each page as Markdown.
That removes a layer of glue code: no SERP API, fetcher and HTML converter. One request gives the model something it can read.
Search is only one of its endpoints. Extract pulls clean content from URLs you already have, Map and Crawl walk a site’s structure, and Research runs multi-step investigations.
Tavily fits three groups well:
- Agent builders who need a search tool their framework already supports (langchain-tavily ships TavilySearch, TavilyExtract, TavilyMap and TavilyCrawl classes).
- RAG teams that want a RAG search engine for fresh public sources, with domain filters and date windows.
- MCP users who want real-time search for AI agents inside Claude, Cursor or any MCP client without writing code.
It doesn’t pretend to be anything else.
That matters later.
Testing Methodology
Most Tavily API review posts quote the docs. Every number in this Tavily review comes from a small Python harness that calls the REST API directly.
Queries. 10 prompts an agent would realistically send:
- 4 freshness queries (topic: news): a model release, a Fed rate decision, a Python release, AI agent funding rounds
- 4 relevance queries: Tavily in LangChain, BM25 vs dense retrieval, Playwright connect_over_cdp, MCP transports
- 2 niche queries: aiohttp rate limiting, pgvector HNSW tuning
Settings. max_results=5, include_raw_content=”markdown”, include_published_date=true, include_usage=true. Every query ran on basic and advanced. For the Tavily vs Exa comparison, the same 10 queries ran on Exa (type: auto, full text).
Crawl limits. I sent 8 URLs to the Extract endpoint, from public docs to a logged-in LinkedIn feed, in both extraction depths.
What I measured. Client-side latency, credits, result count, share of results with a publish date, age of the freshest result, and Markdown volume per query.
The full run consumed 33 Tavily credits (30 for search, 3 for extract) and $0 in pay-as-you-go spend, all inside the free tier.
Benchmark Results: Formats, Latency and MCP
Latency and freshness
| Metric | Tavily basic | Tavily advanced | Exa auto |
|---|---|---|---|
| Latency p50 / p95 | 2.24s / 4.33s | 4.40s / 5.74s | 1.96s / 3.31s |
| Results with a publish date | 44/50 (88%) | 42/50 (84%) | 23/50 (46%) |
| Freshest result, median (news queries) | 10 days | 4 days | 0 days* |
| Markdown per query (avg) | ~108k chars | ~93k chars | ~74k chars |
| Cost for the 10 queries | 10 credits | 20 credits | $0.07 |
Several Exa dates were crawl timestamps rather than publication dates (a Fed press release from October 7 came back dated October 13), so treat that zero with caution.
The headline: advanced search earns its price on time-sensitive queries. On the Fed decision, basic returned a 6-day-old source as its freshest result; advanced returned one from the previous day. On the Python 3.15 release, it went from 26 days to 3.
On evergreen technical questions the gap disappears: basic and advanced returned the same top sources for pgvector and aiohttp.
Search relevance and freshness: Tavily vs Exa
Reading the top-3 URLs side by side tells a clearer story than any metric:
- Exa leaned toward primary sources. openai.com for the model release, federalreserve.gov for the rate decision, the official LangChain docs, and the current MCP specification.
- Tavily advanced leaned toward coverage. News outlets, Medium posts, YouTube, Bloomberg and CNBC. Useful for an agent summarizing what happened, less ideal when it needs the canonical document.
- One miss worth noting. For “Model Context Protocol server specification transports”, Tavily returned two older spec versions (2025-06-18 and 2025-03-26) while a newer one exists. An agent writing code from that would be working off outdated docs.
Where Tavily clearly wins is metadata. 88% of basic results carried a publish date, and those dates were real publication dates. If your agent filters or ranks by recency, that matters more than a few hundred milliseconds.
Output formats
Tavily returns structured JSON results every time: title, url, content, score, plus published_date and raw_content on request. The raw_content field comes as Markdown search output by default, or plain text.
There is no raw HTML option. For LLM pipelines that is a feature. For anyone who needs DOM structure (tables with attributes, embedded JSON-LD), you’ll need a different tool.
One practical warning: raw_content is big. Basic search averaged ~108k characters of Markdown per query, roughly 27k tokens for five pages. The heaviest query (BM25 vs dense retrieval) returned 236k characters. Turn off include_raw_content when the snippet is enough, or lower max_results; otherwise your context window fills before the agent starts thinking.
MCP availability
Tavily offers a hosted Model Context Protocol (MCP) server at https://mcp.tavily.com/mcp/ (API key or OAuth) and a local tavily-mcp npm package, both exposing search and extract as tools.
Connecting it takes one line in most clients: point the client at the remote URL and pass your key as a tavilyApiKey query parameter or an Authorization header, or sign in with OAuth so the key never sits in a config file. For a local setup, npx tavily-mcp reads TAVILY_API_KEY from your environment. Because the server authenticates with your API key, every MCP call draws from the same credit balance as a direct API request, so budget for it the same way.
Tavily Pricing Deep Dive
Tavily pricing is credit-based. A basic search costs 1 credit, an advanced search 2, and extraction costs 1 credit per 5 successful URLs (2 on advanced). Failed extractions are free.
| Plan | Monthly price | Credits | Per 1,000 basic searches | Per 1,000 advanced searches |
|---|---|---|---|---|
| Researcher | Free | 1,000 | Covered (1,000) | Covered (500) |
| Project | $30 | 4,000 | $7.50 | $15.00 |
| Bootstrap | $100 | 15,000 | $6.67 | $13.33 |
| Startup | $220 | 38,000 | $5.79 | $11.58 |
| Growth | $500 | 100,000 | $5.00 | $10.00 |
| Pay as you go | Per use | Per use | $8.00 | $16.00 |
For context, Exa’s own costDollars field put my 10 full-text searches at $0.07, about $7 per 1,000. That lands between Tavily basic and advanced at pay-as-you-go rates.
The whole benchmark, extraction tests included, used 33 credits. The free tier is enough to evaluate the product properly.
Source: Tavily API credits and pricing
Tavily Review: Pros, Cons and Who It Suits
Pros
- Publish dates on 84–88% of results, and they are real publication dates
- Advanced depth cuts the median age of news results from 10 days to 4
- Official LangChain package and a hosted MCP server with OAuth
- Markdown output, and failed extractions cost nothing
Cons
- Tends toward secondary coverage over canonical sources on technical queries
- Returned outdated spec versions on one documentation query
- raw_content volume can blow up token budgets without tuning
- No access to logged-in or session-based pages
Best for: agents and RAG pipelines that need fresh, dated, public-web context with minimal glue code.
Limitations: Public Web Access Only
The Extract test is where the boundary shows up. Same request, eight URLs:
| Page type | Basic | Advanced |
|---|---|---|
| Public docs page | Full content | Full content |
| Practice site, logged out | Full content | Full content |
| LinkedIn feed | Login wall | Login wall |
| GitHub account settings | Failed | Failed |
| Subreddit listing | Failed | Failed |
| Amazon product page | Failed | Specs returned, no price |
| Instagram profile | Public header only | Public header only |
| WSJ Tech section | Headlines only | Headlines only |
None of this is a bug. Tavily fetches every page as an anonymous visitor: no cookies, no account, no memory of the last request.
For public research, that’s exactly right.
For authenticated web data extraction (your CRM, a supplier portal, a dashboard behind SSO, member-only pages), an anonymous fetcher can’t help, however good its index is.
The Gologin Bridge: Tavily for Discovery, Gologin for Logged-In Pages
The fix isn’t a better search API. It’s a browser that stays signed in.
Gologin Cloud Browser runs browser profiles in the cloud and connects over CDP, so existing Playwright or Puppeteer code works by changing one line. Every cloud browser saves cookies. The difference is what else survives between runs: a Gologin profile keeps the same device fingerprint and the same residential IP, a persistent digital identity rather than a fresh machine that happens to know your password. On run 100, the site sees the same returning user it saw on run 1. That holds because fingerprint control lives inside Gologin’s own Chromium build, not in a script layered on top that can contradict the engine underneath.
| Tavily | Gologin Cloud Browser | |
|---|---|---|
| Job | Find and summarize public pages | Open pages as a signed-in, returning user |
| Session state | None, every request is anonymous | Same device fingerprint and IP every run, plus cookies and storage, for the profile’s lifetime |
| Logged-in pages | No | Yes |
| Output | JSON + Markdown | Full browser (you choose the output) |
| Integration | REST, LangChain, MCP | CDP (Playwright, Puppeteer), MCP server |
| Pricing shape | Credits per request | Two metered lines: browser hours + residential proxy traffic ($1/GB beyond plan allowance) |
The two tools split the work cleanly. Tavily handles discovery: which pages matter, which are fresh. Gologin handles access: opening those pages inside a persistent profile that’s already signed in. Your agent gets public context from one and private context from the other, both as Markdown.
I put that to the test with the two protected pages from the Limitations section. On its first visit, the Cloud Browser profile got the same treatment as any new visitor: Amazon showed a “continue shopping” check and Reddit asked for a human verification. I handled both once by hand inside the profile. On the next automated run, with nobody at the keyboard, the profile came back as the same returning visitor: Amazon served the full product page, price included, and r/LocalLLaMA loaded directly. Use it with your own accounts and within each site’s terms.
When a step needs a person (an approval, a two-factor prompt), the session has a live URL someone can take over, and the agent picks up afterwards as the same signed-in user.
Code: Pull Authenticated Pages into Clean Markdown
The demo uses quotes.toscrape.com, a public practice site. Signed-in users see a “Goodreads page” link on every quote, so it’s easy to verify whether the session survived.
Before the first run, the profile has to sign in once. Call first_login() a single time (it ships commented out), or log in manually from the session’s live view. From then on the session is read straight from the profile.
pip install requests playwright beautifulsoup4 markdownifyimport os
import requests
from bs4 import BeautifulSoup
from markdownify import markdownify
from playwright.sync_api import sync_playwright
TAVILY_KEY = os.environ["TAVILY_API_KEY"]
GL_TOKEN = os.environ["GL_API_TOKEN"]
PROFILE_ID = os.environ["GL_PROFILE_ID"]
CDP_URL = f"wss://cloudbrowser.gologin.com/connect?token={GL_TOKEN}&profile={PROFILE_ID}"
FALLBACK_URLS = ["https://quotes.toscrape.com/tag/love/",
"https://quotes.toscrape.com/tag/inspirational/"]
def discover(query):
"""Tavily finds the pages; fall back to known URLs if the domain filter returns nothing."""
resp = requests.post(
"https://api.tavily.com/search",
json={"query": query, "include_domains": ["quotes.toscrape.com"], "max_results": 3},
headers={"Authorization": f"Bearer {TAVILY_KEY}"}, timeout=30,
)
urls = [r["url"] for r in resp.json().get("results", [])]
if not urls:
print("Tavily returned 0 results for quotes.toscrape.com, using fallback URLs")
return urls or FALLBACK_URLS
def first_login(page, username, password):
"""Run once per profile. Afterwards the session lives on the profile."""
page.goto("https://quotes.toscrape.com/login")
page.fill("#username", username)
page.fill("#password", password)
page.click("input[type='submit']")
def to_markdown(html):
soup = BeautifulSoup(html, "html.parser")
for tag in soup(["script", "style", "nav", "header", "footer", "form"]):
tag.decompose()
blocks = soup.select("main, article, .col-md-8") or [soup.body]
main = max(blocks, key=lambda el: len(el.get_text())) # largest content block
return markdownify(str(main), heading_style="ATX", strip=["img"])
def stop_profile():
"""Stop the cloud browser itself; browser.close() only disconnects Playwright."""
resp = requests.delete(f"https://api.gologin.com/browser/{PROFILE_ID}/web",
headers={"Authorization": f"Bearer {GL_TOKEN}"}, timeout=30)
print(f"cloud session stopped: HTTP {resp.status_code}")
urls = discover("quotes about love and inspiration")
with sync_playwright() as p:
browser = page = None
try:
browser = p.chromium.connect_over_cdp(CDP_URL)
page = browser.contexts[0].new_page()
# first_login(page, os.environ["SITE_USER"], os.environ["SITE_PASS"]) # first run only
for url in urls:
page.goto(url, wait_until="domcontentloaded")
signed_in = page.locator("a[href='/logout']").count() > 0
md = to_markdown(page.content())
print(f"{url} | signed in: {signed_in} | "
f"member links: {md.count('Goodreads page')} | ~{len(md) // 4} tokens")
finally:
if page:
page.close()
if browser:
browser.close()
stop_profile()Here is the output from a run on October 16, 2026, three days after the profile’s one-time sign-in, in a fresh cloud session with no login step:
http://quotes.toscrape.com/page/6 | signed in: True | member links: 10 | ~767 tokens
https://quotes.toscrape.com | signed in: True | member links: 10 | ~821 tokens
cloud session stopped: HTTP 204
Both pages loaded as the signed-in user, with all 10 member-only “Goodreads page” links present, and the whole run took about 23 seconds. If signed in ever comes back False, the site has ended the session: sign in once more with the same profile and the following runs pick it up again.
The cleanup in the finally block matters for billing. browser.close() only disconnects Playwright from the CDP session, while the cloud browser itself keeps running. The DELETE request to Gologin’s API is what actually stops it, and the HTTP 204 in the log confirms it did, even if the loop raises an exception halfway through.
From here you can feed the Markdown into:
- a vector store next to your Tavily results,
- an agent tool that answers questions about your own accounts,
- a scheduled job that tracks changes on member-only pages.
FAQs
Is Tavily free?
Yes. The Researcher plan includes 1,000 credits per month with no card, which covers 1,000 basic or 500 advanced searches. This entire benchmark used 33 of them.
How do Tavily search credits work?
Basic search costs 1 credit, advanced costs 2. Extraction costs 1 credit per 5 successful URLs (2 on advanced), and failed extractions aren’t charged.
Tavily vs Exa: which is better?
In my test, Exa was faster (1.96s vs 2.24s p50) and more often returned canonical sources. Tavily returned real publish dates far more consistently (88% vs 46%) and fresher news on advanced depth. Pick Exa for documentation lookups; pick Tavily when recency and dates drive the answer.
How does the Tavily LangChain integration work?
Install langchain-tavily and use TavilySearch as a tool. The older langchain_community Tavily tool is deprecated.
Can Tavily access pages behind a login?
No. It fetches every page as an anonymous visitor. For logged-in pages, pair it with a persistent browser profile such as Gologin Cloud Browser.
Conclusion
This Tavily review comes down to one line: Tavily is one of the best ways to give an agent fresh, dated context from the public web, and it’s honest about where the public web ends.
Most of the data that makes an agent useful lives on the other side of that line.
Use Tavily to find it. Use Gologin Cloud Browser to open it as a returning, signed-in user, then pass both to your model as clean Markdown.
