You.com vs Tavily for AI Agents: Response Shape, Credits, and Choosing by Job

TLDR: You.com and Tavily both give an AI agent live web results through one POST endpoint. You.com returns separate web and news arrays and charges $5.00 per 1,000 calls. Tavily returns one ranked list with an optional inline answer and charges 1 or 2 credits per search, which works out to $5.00 to $16.00 per 1,000 searches depending on depth and plan. Compare them on response shape and cost, then replay your own queries.

Both vendors document one search endpoint, an API key, and JSON in return. What changes an agent's code is the response body, the parameters that steer it, the unit you are billed in, and the limit you hit first. This guide compares those four things as documented in October 2026, then gives you a script that replays your own queries against both. For MCP setup, read the Tavily MCP vs You.com MCP guide. For a wider shortlist, read 5 Tavily alternatives.

What does each API return?

The You.com Web Search API returns a results object with a web array and, when the query has news intent, a news array. Both are optional, so a response can contain either one, both, or neither. Web results carry url, title, description, snippets, page_age, and optional thumbnail and favicon URLs. News results carry url, title, description, page_age, and a thumbnail, with no snippets field. Our JSON response guide covers defensive parsing and how the fields change with extraction modes.

{
  "results": {
    "web": [{
      "url": "https://example.com/docs/streaming",
      "title": "Streaming responses",
      "description": "A short summary of the page",
      "snippets": ["a keyword-centered fragment"],
      "page_age": "2026-08-02T14:10:00"
    }],
    "news": [{
      "url": "https://news.example.com/release",
      "title": "Vendor ships new release",
      "description": "A short summary of the article",
      "page_age": "2026-09-28T09:00:00"
    }]
  },
  "metadata": {"search_uuid": "...", "query": "...", "latency": 0.34}
}

Tavily returns one ranked results list at the top level, next to optional fields. Each result has title, url, content, and a relevance score. By default, content holds up to three chunks of at most 500 characters each, joined by [...], according to the Tavily Search reference. The answer and raw_content fields are empty unless you request them.

{
  "query": "python 3.13 asyncio changes",
  "answer": null,
  "images": [],
  "results": [{
    "url": "https://docs.python.org/3/whatsnew/3.13.html",
    "title": "What's New In Python 3.13",
    "content": "chunk one [...] chunk two [...] chunk three",
    "score": 0.89,
    "raw_content": null,
    "id": "bd194c-00"
  }],
  "response_time": 1.01,
  "request_id": "..."
}

The practical difference is where the text lives. By default You.com gives you short keyword-centered snippets. Set extraction_mode to highlights and each result carries query-relevant passages in contents.highlights instead, or set it to full_page for the whole page as Markdown or HTML, as the page content guide describes. Tavily gives you chunk text by default, include_raw_content for the cleaned page, and an optional LLM-written answer in the same response. You.com's published schema has no per-result score, and Tavily's has no separate news array.

How do the requests differ?

Both are a POST with a JSON body. You.com sends the key in an X-API-Key header to ydc-index.io, as its authentication docs describe. Tavily sends it as a bearer token to api.tavily.com. You.com's GET variant still works, but new features, including extraction and knowledge, ship on POST only.

curl -s -X POST https://ydc-index.io/v1/search \
  -H "X-API-Key: $YDC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "python 3.13 asyncio changes", "count": 5}'

curl -s -X POST https://api.tavily.com/search \
  -H "Authorization: Bearer $TAVILY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "python 3.13 asyncio changes", "max_results": 5}'

Tavily also documents a keyless mode. Send an X-Tavily-Access-Mode: keyless header and Search and Extract run with no account, rate-limited, per its keyless docs. Both vendors publish Python SDKs, but a plain HTTP call keeps the contract visible, so the examples here use it.

Which controls does each search call give you?

Both APIs cover the controls most agents need. The names and limits differ, and a few differences change behavior.

Control	You.com	Tavily
Result count	count, 1 to 100 per section, default 10	max_results, 0 to 20, default 10
Pagination	offset, 0 to 9, in multiples of count	None documented in the Search reference
Freshness	freshness: day, week, month, year, or a YYYY-MM-DDtoYYYY-MM-DD range	time_range: day, week, month, or year; start_date and end_date as YYYY-MM-DD
Domain filters	include_domains, exclude_domains, boost_domains, up to 500 domains each	include_domains (up to 300), exclude_domains (up to 150), include_domains_mode of restrict or prefer
Country and language	country (ISO 3166-1 alpha-2), language (BCP 47)	country and language boost results; filter_by_language filters strictly
Query syntax	site:, filetype:, AND, OR, NOT, and the + and - prefixes, all inside the query	exact_match for quoted phrases; no operators documented
Page text	extraction with highlights or full_page, POST only	include_raw_content: true, markdown, or text
Synthesized answer	Separate Answer API	include_answer: basic or advanced
Topic	News arrives on news intent; knowledge set to core adds licensed data	topic: general, news, or finance

Domain rules differ in ways that break copied configs. You.com returns a 422 when include_domains appears with exclude_domains or boost_domains in the same request, per its request controls and error reference. Tavily's include_domains is a hard filter by default and becomes a preference when include_domains_mode is prefer, so results outside the list can still appear.

Date handling differs too. Tavily keeps results with no detectable publish date unless you set filter_by_published_date to true, and its published_date is a best estimate that can be later than the original publication. For You.com, page_age is the age of the result on web results and a UTC publication timestamp on news results. Neither is documented as a crawl time.

One Tavily setting affects the bill. With auto_parameters on, the service picks parameters from the query and may set search_depth to advanced, which costs 2 credits. Set search_depth explicitly when you want a predictable cost.

What does each one cost?

As of October 2026, the You.com billing page lists the Web Search API at $5.00 per 1,000 calls, with up to 100 results per call and news and knowledge results included at no extra charge. Full-page extraction is an add-on at $1.00 per 1,000 pages fetched live. Under the default blend source, cached pages are free. The pricing page adds $100 in free credit to get started.

Tavily bills in credits. Per its credits documentation, a basic search costs 1 credit and an advanced search costs 2. The free plan includes 1,000 credits a month, pay-as-you-go is $0.008 per credit, and paid plans run from $30 for 4,000 credits to $500 for 100,000. Its pricing page says credits reset on the first day of each month.

Plan (list price, October 2026)	Basic or default search, per 1,000	Advanced search, per 1,000
You.com, pay as you go	$5.00	No depth tiers
Tavily, pay as you go ($0.008 per credit)	$8.00	$16.00
Tavily Project ($30 for 4,000 credits)	$7.50	$15.00
Tavily Bootstrap ($100 for 15,000 credits)	$6.67	$13.33
Tavily Startup ($220 for 38,000 credits)	$5.79	$11.58
Tavily Growth ($500 for 100,000 credits)	$5.00	$10.00

The plan rows divide the monthly price by the included credits, so they assume you use every credit. A concrete case: an agent that runs 30,000 basic searches a month costs $150 on You.com at list price. On Tavily it needs 30,000 credits, which the $220 Startup plan covers, while pay-as-you-go alone would be $240. Move the same traffic to advanced depth and Tavily needs 60,000 credits, while You.com's base price does not change. That compares list prices for different relevance settings, not result quality, and both vendors sell volume discounts through sales.

For evaluation, $100 of You.com credit covers 20,000 calls at the base rate, and Tavily's free plan covers 1,000 basic searches or 500 advanced ones each month. Either fits a replay test of a few hundred queries.

Watch the multiplier before you turn on page extraction. On You.com, full_page crawls every web and news result in the response, so a call with count set to 10 can fetch up to 20 pages. The billing page's own example prices that call at $0.023 when 18 of the 20 pages are crawled live, and $0.025 at most, against $0.005 for the search alone.

How do rate limits and errors compare?

Behavior (October 2026)	You.com	Tavily
Default limit	10 requests per second on /v1/search for self-serve accounts	100 requests per minute on a development key, 1,000 per minute on a production key
Getting more	Custom plan or enterprise contract	Production keys need a paid plan or pay-as-you-go; enterprise is custom
Rate limited (429)	X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers; honor Retry-After	Retry-After when present
Out of budget	402, "Insufficient credits"	432 for a key or plan limit, 433 for the pay-as-you-go limit
Bad request	400 or 422	400 or 422
Bad key	401, or 403 when a key lacks scope	401

Sources: the You.com rate limits and error reference, and the Tavily rate limits and Search reference. Convert units before comparing: 10 requests per second is 600 per minute, while 1,000 per minute is about 16.7 per second. For an agent that fans out parallel searches, size concurrency to the limit that applies to your key.

Retry a 429 after the Retry-After delay. Treat 402, 432, and 433 as budget events that need a plan change, not a backoff loop. One You.com trap appears if you add the Answer or Research API later: they run on api.you.com while search runs on ydc-index.io, and a request sent to the wrong host returns a 403 with Missing Authentication Token.

Which one fits which job?

Pick on the job, then confirm with your own queries. Choose You.com when:

• The agent needs web and news in one call. The news array arrives in the same response when the query has news intent, at no extra charge, so a monitoring agent does not pick a mode up front.
• You filter by domain at scale or write operators. Domain lists take up to 500 entries each, and site:, filetype:, and boolean operators work inside the query itself.
• You want licensed data beside the web results. Setting knowledge to core adds stock and crypto prices, weather, sports, and economic data from licensed providers, per the knowledge guide, at no extra cost.
• You want a bill without a depth setting. One search is one call at $5.00 per 1,000. Page extraction is the add-on to watch.

Choose Tavily when:

• You want the answer in the search response. include_answer returns an LLM-written answer in the same call. On You.com that is the separate Answer API, at $5.00 per 1,000 calls.
• You want a latency and relevance dial. search_depth has four levels, from ultra-fast, which returns one NLP summary per URL, to advanced, which favors relevance at higher latency and 2 credits.
• You threshold on a relevance score. Each Tavily result carries a score. You.com results have none in the published schema.
• You work at the site level. Tavily documents Map and Crawl endpoints beside Search, Extract, and Research. You.com's docs index lists Contents for known URLs, plus Answer, Research, and Finance Research.
• You want to try it without an account. Tavily's keyless header gives free, rate-limited search. You.com has a keyless route through its MCP free profile, limited to 100 queries per day.

Neither schema says anything about recall. A score field is a number the vendor computes, not evidence that your agent gets better sources. If the lists above leave you undecided, the cheapest tie-breaker is data from your own traffic.

How do you test both on your own queries?

The You.com evaluation guide recommends starting from default settings and comparing APIs only within the same latency class. Do the same here: replay a week of real queries with default parameters before you tune anything. Our fair benchmark guide covers freezing a dataset, keeping configurations comparable, and reporting uncertainty.

The script below sends each query to both APIs with a count of 10, Tavily's basic depth, and no optional parameters. It normalizes both responses to url, text, and date, then reports failures and empty responses, median latency, average text length, the share of results with a date, URL overlap, and the list-price cost of the run. Save it as compare_search.py. Running python3 compare_search.py --selftest executes four offline tests that need no keys. Running python3 compare_search.py queries.txt replays your queries with YDC_API_KEY and TAVILY_API_KEY set.

#!/usr/bin/env python3
"""Replay queries against the You.com and Tavily search APIs and compare them.

  export YDC_API_KEY=... TAVILY_API_KEY=...
  python3 compare_search.py queries.txt     # one query per line
  python3 compare_search.py --selftest      # offline: no keys, no network
"""
import json
import os
import statistics
import sys
import time
import unittest
import urllib.error
import urllib.request
from urllib.parse import urlsplit

YOU_URL = "https://ydc-index.io/v1/search"
TAVILY_URL = "https://api.tavily.com/search"
COUNT = 10  # Tavily caps max_results at 20, You.com caps count at 100 per section

# List prices as of October 2026. Re-check before you rely on them:
#   https://you.com/docs/administration/billing
#   https://docs.tavily.com/documentation/api-credits
YOU_USD_PER_CALL = 5.00 / 1000
TAVILY_CREDITS_PER_CALL = {"basic": 1, "advanced": 2}
TAVILY_USD_PER_CREDIT = 0.008  # pay-as-you-go; paid plans lower this


def post_json(url, headers, payload, timeout=20):
    data = json.dumps(payload).encode("utf-8")
    req = urllib.request.Request(url, data=data, method="POST",
                                 headers={"Content-Type": "application/json", **headers})
    start = time.perf_counter()
    with urllib.request.urlopen(req, timeout=timeout) as resp:
        body = json.loads(resp.read().decode("utf-8"))
    return body, time.perf_counter() - start


def you_call(query):
    key = os.environ["YDC_API_KEY"]
    return post_json(YOU_URL, {"X-API-Key": key}, {"query": query, "count": COUNT})


def tavily_call(query, depth="basic"):
    key = os.environ["TAVILY_API_KEY"]
    payload = {"query": query, "max_results": COUNT, "search_depth": depth}
    return post_json(TAVILY_URL, {"Authorization": "Bearer " + key}, payload)


def norm_you(body):
    # results, web, and news are all optional: never index into them directly
    results = (body or {}).get("results") or {}
    out = []
    for section in ("web", "news"):
        for r in results.get(section) or []:
            highlights = (r.get("contents") or {}).get("highlights")
            text = " ".join(highlights or r.get("snippets") or []) or r.get("description") or ""
            out.append({"url": r.get("url") or "", "section": section, "text": text,
                        "date": r.get("page_age")})
    return out


def norm_tavily(body):
    # answer and raw_content are null unless requested; published_date is opt-in
    return [{"url": r.get("url") or "", "section": "web", "text": r.get("content") or "",
             "date": r.get("published_date")} for r in (body or {}).get("results") or []]


def canon(url):
    parts = urlsplit(url)
    host = parts.netloc.lower()
    if host.startswith("www."):
        host = host[4:]
    return host + parts.path.rstrip("/")


def jaccard(a, b):
    a, b = set(a), set(b)
    return len(a & b) / len(a | b) if a | b else 0.0


def run_query(query, calls):
    row = {"query": query}
    for name, (call, norm) in calls.items():
        try:
            body, secs = call(query)
            row[name] = {"ok": True, "secs": secs, "items": norm(body)}
        except urllib.error.HTTPError as exc:
            row[name] = {"ok": False, "status": exc.code, "items": []}
        except (urllib.error.URLError, TimeoutError, ValueError) as exc:
            row[name] = {"ok": False, "status": repr(exc), "items": []}
    return row


def summarize(rows, depth="basic"):
    report = {"queries": len(rows)}
    for name in ("you", "tavily"):
        good = [r[name] for r in rows if r[name]["ok"]]
        items = [i for g in good for i in g["items"]]
        report[name] = {
            "failed": len(rows) - len(good),
            "empty": sum(1 for g in good if not g["items"]),
            "median_secs": round(statistics.median([g["secs"] for g in good]), 3) if good else None,
            "avg_text_chars": round(sum(len(i["text"]) for i in items) / len(items)) if items else 0,
            "dated_share": round(sum(1 for i in items if i["date"]) / len(items), 2) if items else 0.0,
        }
    both = [r for r in rows if r["you"]["ok"] and r["tavily"]["ok"]]
    overlaps = [jaccard([canon(i["url"]) for i in r["you"]["items"]],
                        [canon(i["url"]) for i in r["tavily"]["items"]]) for r in both]
    report["url_overlap"] = round(sum(overlaps) / len(overlaps), 2) if overlaps else None
    report["usd_you"] = round(len(rows) * YOU_USD_PER_CALL, 4)
    report["usd_tavily"] = round(len(rows) * TAVILY_CREDITS_PER_CALL[depth] * TAVILY_USD_PER_CREDIT, 4)
    return report


class OfflineTests(unittest.TestCase):
    YOU = {"results": {
        "web": [{"url": "https://www.example.com/a/", "title": "A", "description": "d",
                 "snippets": ["one", "two"], "page_age": "2026-09-01T00:00:00"},
                {"url": "https://example.org/b", "title": "B", "description": "only a description"}],
        "news": [{"url": "https://news.example.net/c", "title": "C", "description": "news summary",
                  "page_age": "2026-09-30T12:00:00"}]},
        "metadata": {"query": "q", "latency": 0.3}}
    TAVILY = {"query": "q", "answer": None, "images": [], "response_time": 1.0, "results": [
        {"url": "https://example.com/a", "title": "A", "content": "chunk [...] chunk",
         "score": 0.9, "raw_content": None, "id": "x-00"},
        {"url": "https://other.example.io/z", "title": "Z", "content": "zzz", "score": 0.5}]}

    def test_you_shapes(self):
        items = norm_you(self.YOU)
        self.assertEqual([i["section"] for i in items], ["web", "web", "news"])
        self.assertEqual(items[0]["text"], "one two")
        self.assertEqual(items[1]["text"], "only a description")
        self.assertEqual(items[2]["text"], "news summary")  # news has no snippets field
        self.assertEqual(norm_you({}), [])
        self.assertEqual(norm_you({"results": {"news": []}}), [])  # web is optional
        hl = {"results": {"web": [{"url": "u", "contents": {"highlights": ["h1", "h2"]}}]}}
        self.assertEqual(norm_you(hl)[0]["text"], "h1 h2")

    def test_tavily_shapes(self):
        items = norm_tavily(self.TAVILY)
        self.assertEqual(len(items), 2)
        self.assertIsNone(items[0]["date"])
        self.assertEqual(norm_tavily({"results": None}), [])

    def test_overlap_ignores_www_slash_and_query(self):
        self.assertEqual(canon("https://www.Example.com/a/?x=1#f"), "example.com/a")
        self.assertAlmostEqual(jaccard(["a", "b"], ["b", "c"]), 1 / 3)
        self.assertEqual(jaccard([], []), 0.0)

    def test_run_and_summarize(self):
        def ok(body):
            return lambda q: (body, 0.4)

        def limited(q):
            raise urllib.error.HTTPError(TAVILY_URL, 429, "Too Many Requests", {}, None)
        good = run_query("q", {"you": (ok(self.YOU), norm_you), "tavily": (ok(self.TAVILY), norm_tavily)})
        bad = run_query("q2", {"you": (ok(self.YOU), norm_you), "tavily": (limited, norm_tavily)})
        self.assertEqual(bad["tavily"]["status"], 429)
        report = summarize([good, bad])
        self.assertEqual(report["tavily"]["failed"], 1)
        self.assertEqual(report["you"]["failed"], 0)
        self.assertAlmostEqual(report["url_overlap"], 0.25)  # 1 shared URL of 4 distinct
        self.assertEqual(report["usd_you"], 0.01)
        self.assertEqual(report["usd_tavily"], 0.016)


if __name__ == "__main__":
    if "--selftest" in sys.argv:
        unittest.main(argv=[sys.argv[0]], verbosity=2)
    if len(sys.argv) != 2 or not (os.environ.get("YDC_API_KEY") and os.environ.get("TAVILY_API_KEY")):
        sys.exit("usage: python3 compare_search.py queries.txt (set YDC_API_KEY and TAVILY_API_KEY)")
    with open(sys.argv[1], encoding="utf-8") as fh:
        queries = [line.strip() for line in fh if line.strip()]
    calls = {"you": (you_call, norm_you), "tavily": (tavily_call, norm_tavily)}
    print(json.dumps(summarize([run_query(q, calls) for q in queries]), indent=2))

The fixtures follow each vendor's published schema, and we ran the Tavily normalizer against one real keyless response. The tests check parsing and arithmetic, not retrieval quality. No keyed calls were made while writing this guide, so run the script with your own keys before relying on any number it prints.

Read the output in this order:

• Failures and empties. A failed call and an empty result list are different events. Count both before comparing anything else.
• Overlap. Low URL overlap tells you to read the disagreements, not which API is right. Matching URLs can carry weak evidence, and different URLs can be equally useful. Grade the 20 queries with the lowest overlap by hand.
• Text length and dates. Longer text costs tokens, and a missing date breaks freshness logic. Check both against what your prompt template needs.
• Cost. The script prices every query at list price with no page extraction. Replace its constants with your real mix of depth and extraction.

Then change one parameter at a time. Turn on highlights for You.com or advanced depth for Tavily, rerun, and compare cost per answered question, not cost per call.

Related Guides

• You.com vs Exa for AI Agents: What Each Search API Returns
• SerpApi vs Tavily for AI Agents in 2026: Which Search API Should You Use?
• Tavily vs Exa: Comparing AI Search APIs for Developers