Tavily pricing explained, and a half-price drop-in option

If you are building retrieval, agents, or research workflows, you have probably reached for Tavily as your web search API. It works well, but the moment you move from a weekend prototype to real traffic, the question changes from "does it work?" to "what is this going to cost at scale?" This guide breaks down how Tavily pricing actually works, where the bill grows fastest, and how a fully compatible alternative cuts the per-credit rate in half without changing your code.

How Tavily pricing works: a credit model

Tavily bills on a credit system rather than a flat per-request fee. You buy credits (or get a monthly allotment on a plan), and every API call deducts a number of credits depending on which endpoint you hit and how heavy the request is. The mental model is simple: usage is metered in credits, and credits map to dollars at a per-credit list price.

The key thing to internalize is that not all calls cost the same. The endpoints you have available are the same ones any search-and-retrieve stack needs:

• /search — the workhorse. A basic search costs less; an advanced / deep search consumes more credits because it does more retrieval and ranking work.
• /extract — pull clean content from URLs you already have. Billed by how many URLs and how deep the extraction goes.
• /crawl and /map — walk a site and discover its structure. These fan out across many pages, so credit usage scales with the crawl.
• /research — the heaviest, since it chains search and extraction into a single deeper task.

So your effective cost is not one number; it is a weighted blend of which endpoints your application leans on and how deep each call goes. A chatbot that fires one basic search per turn has a very different bill from an agent that runs advanced searches and extracts a dozen URLs per task.

Pay-as-you-go vs. plans

Two billing shapes show up in practice. Pay-as-you-go means you top up credits and draw them down — clean and predictable for variable traffic. Subscription plans bundle a monthly credit allowance, sometimes with a lower effective per-credit rate, but you commit up front and can over- or under-buy. For exact current numbers, always check Tavily's own pricing page; plans and allowances change. What does not change is the underlying unit: you are paying per credit, and the list price per credit is the lever that moves your whole bill.

Where the bill grows at scale

Three patterns reliably inflate a credit-based search bill:

• Depth creep. Defaulting every call to advanced / deep search "just to be safe" can multiply per-call cost when basic would have answered the query.
• Fan-out from agents. Autonomous agents tend to issue many searches and extractions per task. Multiply credits-per-task by tasks-per-day and the number gets real fast.
• Crawl and research jobs. A single crawl or research call can quietly consume far more credits than a search, because it touches many pages at once.

The honest takeaway: the per-credit list price is multiplied by everything you do. Halving that base rate halves the whole curve, no matter which endpoints dominate your mix.

A worked example

Suppose your agent platform runs a workload that consumes 1,000,000 credits per month — a realistic figure once you are in production. At a per-credit list price of $0.008, that is $8,000/month. Run the identical workload on a provider priced at $0.004 per credit and the same million credits cost $4,000/month — a flat 50% cut, $48,000/year, with no change to how many credits you burn. Because the credit model and per-endpoint costs are identical, your usage forecast does not move; only the multiplier does.

The half-price, fully compatible alternative

BestSearch is a drop-in web search API that mirrors Tavily one-for-one — the same 5 endpoints (/search, /extract, /crawl, /map, /research), the same request parameters, the same JSON response shapes, and the same credit accounting — at $0.004 per credit instead of $0.008. Because the contract is identical, migrating is a configuration change, not a rewrite. You keep the Tavily SDK and just repoint the base URL:

import os
from tavily import TavilyClient

# Same SDK, same methods. Only the base URL changes.
client = TavilyClient(
    api_key=os.environ["BESTSEARCH_API_KEY"],
    api_base_url="https://app.websearchapi.tech",
)

resp = client.search("latest LLM eval benchmarks", search_depth="advanced")
print(resp["results"][0]["url"])

Prefer raw HTTP? The same call over curl looks exactly like a Tavily request, only the host differs:

curl -s https://app.websearchapi.tech/search \
  -H "Authorization: Bearer $BESTSEARCH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "tavily pricing", "search_depth": "advanced"}'

That is the entire migration. If you want the side-by-side feature and field comparison, see the Tavily alternative breakdown, and the exact per-credit numbers live on the pricing page. Full request and response references are in the docs.

How to think about your own Tavily pricing

• Measure your real credit mix: log credits per endpoint for a week before optimizing anything.
• Reserve advanced / deep search for queries that genuinely need it; let basic handle the rest.
• Cache and dedupe — repeated identical searches are pure waste in any credit model.
• Once your usage is stable, the biggest lever left is the per-credit rate itself. That is exactly where a compatible half-price provider pays off.

None of this requires giving up the API you already integrated. The credit model is the same; the only thing you are changing is the price per credit.