Tavily pricing explained: what each API call costs in credits
Tavily charges 1 credit per basic search and $0.008 per credit pay-as-you-go. We priced every endpoint, plan and MCP default against 27 live calls.

Tavily bills in one unit, the API credit. Pay-as-you-go costs $0.008 per credit, and the four monthly plans cost $0.0075 to $0.005 per credit. A basic search costs 1 credit and an advanced search costs 2. Page extraction costs 1 credit for every 5 successful URLs, and a site map costs 1 credit for every 10 pages. One research report costs 4 to 250 credits. The value of the $30 Project plan depends on one rule that Tavily does not state. If the free 1,000 credits still count after you turn on pay-as-you-go, Project costs $6 more than free plus pay-as-you-go at every volume. If they do not count, Project saves at most $2 a month.
On 2026-11-18, from 00:17 to 00:35 SGT, we ran the same searches, page reads, crawls and site maps on EveryInfra. The 14 calls that match Tavily search and Extract one to one cost $0.0097. Under Tavily's rules, the same work comes to 10.4 credits: $0.083 on pay-as-you-go or $0.052 at the Growth rate. Two site maps and two crawls convert by page count to another 41.8 credits. We did not compare the output quality of those four calls.

All Tavily numbers here come from Tavily's own pages. These are the credits documentation, the pricing page, the help center plan article and the endpoint references. We read them from 00:10 to 00:25 SGT on 2026-11-18. We did not open a Tavily account, and we did not call the Tavily API.
The EveryInfra numbers are the billing.charged_usd values from three rounds of live calls on the same night. For a five-vendor price comparison, read our Tavily alternatives comparison.
Tavily pricing at a glance: five plans, pay-as-you-go and the free tier
The Tavily pricing page shows three cards. The free Researcher plan gives 1,000 credits a month. Pay-as-you-go costs $0.008 per credit. Project costs $30 for 4,000 credits. Three more tiers sit in a slider on the Project card. We read the slider data from the page script, and it matches the help center plan list.
Bootstrap costs $100 for 15,000 credits. Startup costs $220 for 38,000 credits. Growth costs $500 for 100,000 credits.
Enterprise has no public price; its card lists custom API calls, custom rate limits, enterprise-grade support with SLAs, and enterprise-grade security and privacy. The pricing page FAQ gives two budget rules. Credits reset on the 1st of every month, whatever your billing date. When credits run out, requests stop until the reset or an upgrade.
| Plan | Monthly fee | Credits per month | Price per credit | Per 1,000 basic searches | Per 1,000 advanced searches | Requests per minute |
|---|---|---|---|---|---|---|
| Researcher (free) | $0 | 1,000 | n/a | first 1,000 free | first 500 free | 100 |
| Pay-as-you-go | usage only | n/a | $0.008 | $8.00 | $16.00 | 1,000 |
| Project | $30 | 4,000 | $0.0075 | $7.50 | $15.00 | 1,000 |
| Bootstrap | $100 | 15,000 | $0.00667 | $6.67 | $13.33 | 1,000 |
| Startup | $220 | 38,000 | $0.00579 | $5.79 | $11.58 | 1,000 |
| Growth | $500 | 100,000 | $0.005 | $5.00 | $10.00 | 1,500 |
| Enterprise | custom | custom | custom | custom | custom | custom |
The last column comes from the rate limits page. Pay-as-you-go lifts a free account from 100 to 1,000 requests per minute. That is the same limit as Project, Bootstrap and Startup. The rate limits page also names a Scale tier at 1,500 requests per minute, but no Tavily page gives its price. Pay-as-you-go and a plan can run together.
The credits page says pay-as-you-go charges begin "once your plan's credit limit is reached". All bill curves in this article use that model.
Project: $6 more or $2 less, depending on the free credits
Write each option as a monthly fee plus overage at $0.008 per credit. Then compare the options at each monthly volume. With the free 1,000 credits used first, 4,000 credits on pay-as-you-go cost $24. Project costs $30 for the same 4,000 credits. Above 4,000 credits, both options rise at $0.008 per credit, so the $6 gap stays. Below 4,000 credits, Project still costs $30.
Why does the lower unit price lose? Project saves $0.0005 per credit, which is $2 across 4,000 credits. The free tier's 1,000 credits are worth $8, so the free route wins.
Our pricing script checked every volume from 0 to 150,000 credits in steps of 50. Free plus pay-as-you-go was cheapest up to 13,500 credits, and Bootstrap was cheapest up to 30,000. Startup was cheapest up to 73,000, and Growth above that. Project was never the cheapest option.
This result assumes that the free 1,000 credits still apply when pay-as-you-go is on. That is how we read the credits page. If pay-as-you-go billed from the first credit, Project would save a fixed $2 a month above 4,000 credits. In both readings, Project saves at most $2 a month. Its unused credits expire, and it gives no extra rate limit.
| Credits used per month | Free credits first: free + pay-as-you-go | Strict reading: pay-as-you-go from credit 1 | Project, overage pay-as-you-go | Bootstrap, overage pay-as-you-go |
|---|---|---|---|---|
| 2,000 | $8 | $16 | $30 | $100 |
| 4,000 | $24 | $32 | $30 | $100 |
| 8,000 | $56 | $64 | $62 | $100 |
| 20,000 | $152 | $160 | $158 | $140 |
At 4,000 credits, the two readings point in opposite directions: Project costs $6 more or $2 less. At 20,000 credits, Bootstrap is cheapest under both readings, at $100 plus $40 of overage.
You can settle the question for less than a dollar. The account part of the /usage endpoint has plan_usage, plan_limit and paygo_usage. On a free account, turn on pay-as-you-go with a low spending cap. Use 1,000 credits, send one more basic search, and read /usage. If paygo_usage starts at credit 1,001, the free credits come first and the breakpoints above hold. If it grows from the first request, Project wins above 3,750 credits a month, by at most $2. We have no Tavily account, so we did not run this check. All plan math in this article uses the free-credits-first reading.
The Tavily review on frontal.so says "A plan beats pay as you go from the first step". That is true for unit price only. When you count the free credits and the monthly expiry, no volume favors Project, if the free credits are used first. Under the strict reading, Project saves $2 a month and still loses its unused credits. The same review gives development keys 100 requests per minute and production keys 1,000. The November 2026 changelog changed this: all keys in an organization now share one limit. Check third-party numbers against Tavily's pages for the current month.
Three more credit sources sit outside the plans. The startup program gives accepted teams 100,000 credits. The student account page says students use Tavily free. Keyless access lets you call search and extract with the header X-Tavily-Access-Mode: keyless. You need no account and spend no credits, but a fair-use rate limit applies. The Tavily CLI docs agree: search and extract work without sign-in, and crawl, map and research need credentials.
One keyless detail affects billing. If a request has both the keyless header and a valid Authorization: Bearer header, the key wins. The request then spends account credits. Tavily's own local MCP server picks the mode from the environment. In the tavily-mcp source, line 14 loads a local .env file with dotenv. Lines 16 and 17 read const API_KEY = process.env.TAVILY_API_KEY; const IS_KEYLESS = !API_KEY;. If the variable is set, every request carries the key. The setup notes for the TavilySearch tool in langchain-tavily tell you to export TAVILY_API_KEY. So clear the variable before you test keyless mode. Without a key, tavily-mcp offers only search and extract; crawl, map and research return a message that asks for an API key. Keyless and keyed responses have identical fields, so only include_usage or /usage shows the difference.
Tavily pricing per search: basic, advanced and auto_parameters
The search endpoint reference defines four values for search_depth. Advanced costs 2 credits, and basic, fast and ultra-fast cost 1 credit each. Fast and ultra-fast came in January 2026 at the basic price, so they save time, not money. Ultra-fast returns one summary snippet per URL. The other three depths return up to chunks_per_source chunks per URL, 3 by default. A chunk is about 500 characters at basic and fast, and about 800 characters at advanced.
A search returns 10 results by default and up to 20. The result count does not change the credit charge. The max_age_hours parameter sets cache freshness, and the reference says lower values do not cost more credits. Per 1,000 searches, basic costs $8 on pay-as-you-go and $5 at the Growth rate. Advanced costs $16 and $10.
The auto_parameters flag can raise the depth to advanced. When it is on, Tavily sets parameters from the query, and search_depth can become advanced at 2 credits. To prevent this, set search_depth to basic explicitly. The search best practices guide does this in its sample code, with the comment "Override to control cost". With auto_parameters on, the worst-case monthly bill is twice the all-basic bill.
To see the cost of each call, add include_usage: true to the request. The response then has a usage.credits field. The best practices guide tells batch users to add up these values to check the bill. Result count and chunk count do not change credits, but they change tokens. A default basic search returns about 15,000 characters of chunks, and the model bills for reading them.
Third-party measurements agree with these rules. gologin's Tavily review, published 2026-10-20 and updated 2026-10-28, ran 10 agent-style queries at basic and at advanced. Basic used 10 credits and advanced used 20. On news queries, advanced cut the median age of the newest result from 10 days to 4. On documentation queries, both depths returned the same top sources. AIMultiple's agentic search benchmark, updated 2026-11-10, scored Tavily ultra-fast at 26.3% on current-fact questions.
| What you want | Tavily parameters | Credits per call | Per 1,000 pay-as-you-go | Per 1,000 at Growth | EveryInfra tool | Charged per 1,000 |
|---|---|---|---|---|---|---|
| 10 snippets | basic or fast | 1 | $8.00 | $5.00 | web | $0.694 |
| Low-latency snippets | ultra-fast | 1 | $8.00 | $5.00 | web | $0.694 |
| Deeper retrieval | advanced | 2 | $16.00 | $10.00 | deep | $0.694 |
| Tavily decides | auto_parameters: true | 1 to 2 | $8 to $16 | $5 to $10 | n/a | n/a |
| Full page text | basic plus include_raw_content | 1 | $8.00 | $5.00 | deep with full=true | $0.694 |
| 20 results | max_results: 20 | 1 | $8.00 | $5.00 | web, two pages | $1.388 |
We ran our matching tools in all three rounds. At 00:17:29 SGT, web searched "tavily pricing" and returned 10 results in 1.91 seconds for $0.000694. At 00:34:20 SGT, the same query returned the same 10 URLs in the same order. The charge was the same.
deep without full text ran at 00:26:37 SGT and took 48.5 seconds for 5 results. The deep calls with full=true at 00:27:34 SGT and 00:34:30 SGT returned 41,070 and 31,701 characters of page text. Each call cost $0.000694.
The table pairs deep with advanced by purpose only. Each side has its own ranking and its own response fields. The table compares price, not output.
Tavily extract pricing: 1 credit per 5 successful URLs, counted across requests
The credits page and the extract endpoint reference give the same rule. Basic extraction costs 1 credit for every 5 successful URLs. Advanced costs 2 credits for every 5. Failed URLs are free. One request takes up to 20 URLs, and more than 20 returns a 400 error. The default timeout is 10 seconds for basic and 30 seconds for advanced.

What does one single-URL extraction cost? The docs do not say it directly, but the include_usage description answers it. It says the value "may be 0 if the total successful URL extractions has not yet reached 5". The Map reference says the same for fewer than 10 pages. So Tavily counts successful URLs across your account and books 1 credit at every fifth URL. It does not round up for each request.
Under this rule, one single-URL extraction costs 0.2 credits on average. That is $1.60 per 1,000 URLs on pay-as-you-go and $1.00 at the Growth rate. Advanced extraction doubles these prices. In gologin's test, 8 URLs went through both depths. Three extractions failed, and the whole Extract run used 3 credits. That result fits the rule: failures are free, and successes accumulate.
This rule makes single readings unreliable. An agent that extracts one URL per call can see 0 on four calls and 1 on the fifth. If you multiply one reading by the call count, the estimate is wrong. Add up usage across all responses, or use extract_usage from /usage. With full batches of 20 successful URLs, each call shows a steady 4 credits.
Extract is where Tavily comes closest to us on price. Our read tool takes one URL per call at $0.000694. That makes 1,000 URLs cost $0.694, which is 1.4 to 2.3 times less than Tavily basic. Between 00:27:59 and 00:28:39 SGT, we used read on five Tavily documentation pages. The calls took 0.79 to 3.30 seconds and cost $0.00347 in total. The same five URLs in one Tavily basic request would cost 1 credit, or $0.008 on pay-as-you-go.
At 00:29:13 SGT, we asked read for a Tavily page that does not exist. The response was a 404 with charged_usd set to 0 and reason set to request_failed_refunded. Both services handle this case the same way: a page that cannot be fetched costs nothing.
| URLs per call | Tavily basic credits | Tavily advanced credits | Basic, pay-as-you-go | Basic, Growth | EveryInfra `read` |
|---|---|---|---|---|---|
| 1 | 0.2 (accumulated) | 0.4 (accumulated) | $0.0016 | $0.0010 | $0.000694 |
| 5 | 1 | 2 | $0.0080 | $0.0050 | $0.003470 |
| 20 (request limit) | 4 | 8 | $0.0320 | $0.0200 | $0.013880 |
| Per 1,000 URLs | 200 | 400 | $1.60 | $1.00 | $0.694 |
Extract also has a cost outside credits: tokens. In gologin's test, include_raw_content returned about 108,000 characters per query. The author estimated about 27,000 tokens for five pages, and the model bills them separately. Tavily's extract best practices suggest chunks_per_source to keep only relevant passages. The guide recommends advanced for JavaScript pages, tables, rich media, or a higher success rate. Because failures are free, extract at basic first, then retry only the failed URLs at advanced.
Map and Crawl: priced by page count, capped by limit
The map endpoint reference charges 1 credit for every 10 successful pages. With natural-language instructions, the charge is 2 credits per 10 pages. A failed request is free. The defaults are max_depth 1, max_breadth 20 and limit 50. A Map call that reaches the default limit returns 50 pages for 5 credits, or $0.04 on pay-as-you-go. With limit 200 and instructions, the same call costs 40 credits, or $0.32.
The crawl endpoint reference defines Crawl as Map plus Extract, and the bill adds both parts. The credits page gives an example. A 10-page crawl with basic extraction costs 3 credits: 1 for mapping and 2 for extraction. With advanced extraction, it costs 5 credits. With instructions, the Map part doubles. So a 20-page basic crawl costs 6 credits, and a 50-page advanced crawl with instructions costs 30.
The crawl best practices list "no limit set" as a common pitfall. The stated result is "runaway crawls, unexpected costs". Map has its own rate limit of 100 requests per minute on every plan.
We ran our map and crawl tools twice each on the Tavily and Firecrawl documentation sites. At 00:19:42 SGT, map listed docs.tavily.com and returned 110 URLs in 0.44 seconds. At 00:35:15 SGT, map listed docs.firecrawl.dev with num set to 200 and returned 200 URLs. Each call cost $0.000694. Under Tavily's rules, these two maps would cost 11 and 20 credits.
At 00:20:26 SGT, crawl fetched docs.tavily.com/documentation with an instruction about pricing, credits and API reference pages. It returned 12 pages and 150,670 characters in 7.57 seconds. The first page was the credits documentation. At 00:35:05 SGT, a crawl of the API reference without instructions returned 20 pages in 1.38 seconds. Each crawl cost $0.000694. In Tavily, these two crawls would cost 4.8 and 6 credits.
In Tavily, page count sets the price. Page count depends on limit, max_depth, max_breadth and the site, and an agent cannot know it before the call. Our map returns up to 200 URLs per call, and crawl returns up to 20 pages per call. Both are charged per call, so page count changes only the latency.
Research: a floating price from 4 to 250 credits
The research endpoint reference gives the whole job to Tavily. Tavily splits the question, searches several times, reads sources and writes a cited report. The credits page calls this dynamic pricing. model=mini costs 4 to 110 credits per request, and model=pro costs 15 to 250 credits. On pay-as-you-go, mini costs $0.032 to $0.88 and pro costs $0.12 to $2.00.
The model parameter defaults to auto, and Tavily then picks mini or pro. A call without an explicit model can therefore cost up to 250 credits. The reference describes mini for "narrow or well-scoped questions" and pro for complex topics that cover several fields. Research has its own limit of 20 requests per minute. The upper bounds set the budget:
| Plan credits | Research calls at the mini ceiling (110) | Research calls at the pro ceiling (250) | Cheapest case, mini (4) |
|---|---|---|---|
| Free, 1,000 | 9 | 4 | 250 |
| Project, 4,000 | 36 | 16 | 1,000 |
| Bootstrap, 15,000 | 136 | 60 | 3,750 |
| Growth, 100,000 | 909 | 400 | 25,000 |
To keep research costs predictable, set model=mini explicitly. Also keep the questions in the agent prompt narrow, so that Tavily runs fewer search rounds.
We have no report endpoint like Research. Our closest tool is crosscheck. It runs one question through four retrieval methods in parallel and groups the sources by how many methods found them. It returns evidence, not a written answer. At 00:35:34 SGT, we used it to check the Tavily pay-as-you-go price of $0.008 per credit. It finished in 5.44 seconds, and three methods found the Tavily credits page.
That call cost $0.002778, from usage.charged_usd. The two products deliver different things, so we do not give a multiplier. The cheapest Research mini call costs $0.02 to $0.032. One crosscheck call costs $0.002778.
Tavily MCP pricing: one balance, and the defaults decide the bill
Tavily's remote MCP server runs at https://mcp.tavily.com/mcp/. The MCP docs list five tools: tavily_search, tavily_extract, tavily_crawl, tavily_map and tavily_research. You can sign in with OAuth, a tavilyApiKey URL parameter, or an Authorization header. OAuth uses an account key named mcp_auth_default, and the whole organization shares it. MCP has no separate price list. Each tool call is a normal API request, charged under the same rules from the same balance.
OAuth also makes the bookkeeping harder. /usage reports by key, so one shared key hides whose agent spent the credits. To split usage by person, give each client its own key. These keys still share the organization's rate limit.
The tool descriptions and defaults guide the model. We read the source of the official server, GitHub tavily-ai/tavily-mcp, at its 2026-11-13 commit. In tavily_search, search_depth defaults to basic. Its description says: "Use 'advanced' when looking for a specific fact, page or entity, or when 'basic' did not find it." max_results defaults to 5. tavily_crawl and tavily_map default to limit 50, and tavily_research defaults model to auto.

That description goes into the model's context. Following it, a model may search at basic, find nothing, and search again at advanced. That one question costs 3 credits. Tavily's LangChain package, langchain-tavily, pushes the same way. When its TavilySearch tool gets no results at basic, the error text suggests "Try a more detailed search using 'advanced' search_depth". The credits page does not say if an empty basic search costs a credit. To check, send a query with no results and include_usage: true, then read usage.credits. We have no Tavily account, so we did not test this.
The second lever is DEFAULT_PARAMETERS. The remote server accepts a JSON object in a request header as default parameters for every call. The example in the docs is {"include_images":true, "search_depth": "advanced", "max_results": 10}. A local tavily-mcp server reads an environment variable with the same name.
In the source, every key that is also in the defaults gets the default value. A search_depth from the model is overwritten too. If you copy the docs example, every search costs 2 credits, and the bill doubles.
| One question in MCP | Calls | Tavily credits | Pay-as-you-go | Growth |
|---|---|---|---|---|
| Default basic search | tavily_search | 1 | $0.008 | $0.005 |
DEFAULT_PARAMETERS set as in the docs example | tavily_search (forced to advanced) | 2 | $0.016 | $0.010 |
| Basic finds nothing, retry at advanced | tavily_search x2 | 3 | $0.024 | $0.015 |
| Search, then extract the top 3 results | tavily_search + tavily_extract | 1.6 | $0.0128 | $0.008 |
| Site crawl with defaults, runs to 50 pages | tavily_crawl | 15 | $0.12 | $0.075 |
Hand it to research, model=auto | tavily_research | 4 to 250 | $0.032 to $2.00 | $0.02 to $1.25 |
In the Tavily CLI, tvly set-default turns off a coding agent's built-in web search, so Tavily handles every lookup. tvly setup mcp writes the remote server into the Claude Code, Codex and Cursor configurations. After this setup, every web lookup spends Tavily credits. To track MCP costs, use include_usage or /usage. The remote server also tags each session with an X-Session-Id.
Our remote MCP server runs at https://api.everyinfra.com/mcp. Its everyinfra_search tool contains the web, deep, read, crawl, map and crosscheck sub-tools. At 00:29:31 SGT, we called web through MCP with the query "tavily mcp pricing credits". It returned 10 results in 2.60 seconds for $0.000694, the same as a direct API call. Our tools have no depth setting that doubles the price. The full client list is on our MCP server page, and Claude Code needs one command:
claude mcp add --transport http everyinfra https://api.everyinfra.com/mcp \
--scope user \
--header "Authorization: Bearer ${EVERYINFRA_API_KEY}"Unused credits: the real price per credit when you do not use them all
The plan price per credit assumes that you use all credits that month. The pricing page says credits reset on the 1st and does not mention rollover. Unused credits are therefore lost at month end. The real price per credit is the monthly fee divided by the credits you used. At half use, Project costs $0.015 per credit, Bootstrap $0.0133, and Growth $0.01. Growth at half use costs more than the $0.008 pay-as-you-go rate.
At a quarter of the allowance, all four plans cost $0.02 to $0.03 per credit. That is 2.5 to 3.75 times the pay-as-you-go price. So buy a plan only for the volume that you use every month. Leave the variable part to pay-as-you-go. Growth saves $0.00079 per credit compared with Startup, but only at full use.
Other vendors treat expiry differently. On the Firecrawl pricing page, only the Scale plan rolls credits over, for one month. Serper prepaid packs last 6 months. SerpAPI moves leftover searches to an extra balance when you downgrade. An EveryInfra balance does not reset.
Rate limits, error codes and the pay-as-you-go cap
In November 2026, Tavily moved rate limits to the organization level. All keys in an organization share one limit, development and production keys included. The rate limits page says "Each request counts once, regardless of its parameters". The free plan allows 100 requests per minute, and Growth allows 1,500. Crawl and Map have a limit of 100 per minute and Research 20, on every plan.
Four error codes matter for money. The search reference lists all of them, and each needs a different response in the agent's retry logic:
| Code | Meaning | Agent response | Extra cost |
|---|---|---|---|
| 429 | Rate limit hit | Wait for Retry-After, then resend | None |
| 432 | Key or plan credit limit reached | Stop and report to a person; resending will not help | None |
| 433 | Your pay-as-you-go cap reached | Stop; a person decides whether to raise the cap | None |
| 434 | Free tier "Flex tier capacity exceeded" with max_age_hours | Drop max_age_hours and accept cached results | None |
The pay-as-you-go cap is the main budget switch. Without a cap, an agent in a loop can spend until month end. On EveryInfra, our test key has its own limit of 10 requests per minute. From 00:17:37 to 00:17:56 SGT, we hit it four times. Each 429 response said "Nothing was charged" and gave a retry_after of 23 seconds. At 00:29:22 SGT, a request with no key returned 401, also with no charge.
Checking the bill: include_usage, /usage and X-Project-ID
Tavily gives three levels of bill checks. The first is include_usage on one request, which adds usage.credits to the response. For Extract and Map it can show 0 until the count reaches 5 URLs or 10 pages. The second is the /usage endpoint. It returns the period total for a key, split into search_usage, extract_usage, crawl_usage, map_usage and research_usage.
The third level is the X-Project-ID header from the headers page. When one key serves several projects, each request can carry a project ID. Logs, the usage dashboard and /usage can then split usage by project. The /usage endpoint allows only 10 calls every 10 minutes, so use it for scheduled summaries.
This Tavily request uses include_usage. We built it from the search reference but did not run it, because we have no Tavily account. It sets the depth to basic, turns off auto_parameters and adds a project ID:
curl -X POST https://api.tavily.com/search \
-H "Authorization: Bearer $TAVILY_API_KEY" \
-H "X-Project-ID: pricing-audit" \
-H "Content-Type: application/json" \
-d '{"query":"tavily pricing","search_depth":"basic","auto_parameters":false,"max_results":10,"include_usage":true}'Every EveryInfra response has a billing block. charged_usd is the cost of that call, and list_price_credits is the catalog price. On a failure or an empty result, charged_usd is 0 and reason gives the cause. At 00:29:03 SGT, a search for made-up words returned 0 results with reason set to empty_result_refunded. At 00:28:51 SGT, we sent Tavily-style query and search_depth fields. The response was a 422 with unknown_param, did_you_mean set to q, and "Nothing was charged".

An agent that reads this 422 can rename the field and send the request again.
The same night's work on EveryInfra, and what it would cost in Tavily credits
The three rounds ran from 00:17 to 00:35 SGT and produced 27 charged calls, $0.021009 in total. Four rate-limit responses, one 422, one 401, one 404 and one empty result cost $0. The table shows 19 of the charged calls, all search-tool calls, at $0.015270 in total. It puts them in three groups. Group 1 has 14 calls that match one to one: web maps to basic search, deep to advanced, deep with full text to basic with include_raw_content, and read to single-URL basic Extract. Group 2 has 4 map and crawl calls, converted by page count only; we did not compare the pages that each side returns. Group 3 is crosscheck. It delivers something different from Research, so we list its price but do not convert it.
| Time (SGT) | EveryInfra tool | Returned | Charged | Same work in Tavily credits |
|---|---|---|---|---|
| 00:17:29 | web | 10 results | $0.000694 | 1 |
| 00:19:06 | deep | 5 results | $0.000694 | 2 |
| 00:19:29 | read | 1 page | $0.000694 | 0.2 |
| 00:26:37 | deep | 5 results | $0.000694 | 2 |
| 00:27:34 | deep full | 5 full pages | $0.000694 | 1 |
| 00:27:59 to 00:28:39 | read x5 | 5 pages | $0.003470 | 1 |
| 00:29:31 | MCP everyinfra_search to web | 10 results | $0.000694 | 1 |
| 00:34:20 | web | 10 results | $0.000694 | 1 |
| 00:34:30 | deep full | 5 full pages | $0.000694 | 1 |
| 00:34:57 | read | 1 page | $0.000694 | 0.2 |
| Group 1 subtotal: search and Extract | 14 calls | $0.009716 | 10.4 | |
| 00:19:42 | map docs.tavily.com | 110 URLs | $0.000694 | 11 (by page count) |
| 00:20:26 | crawl with instructions | 12 pages | $0.000694 | 4.8 (by page count) |
| 00:35:05 | crawl | 20 pages | $0.000694 | 6 (by page count) |
| 00:35:15 | map docs.firecrawl.dev | 200 URLs | $0.000694 | 20 (by page count) |
| Group 2 subtotal: site maps and crawls | 4 calls | $0.002776 | 41.8 | |
| 00:35:34 | crosscheck (group 3) | four methods agree | $0.002778 | not converted |
| Total | 19 calls | $0.015270 | n/a |
We give a multiplier for group 1 only. Its 10.4 credits cost $0.0832 on pay-as-you-go and $0.052 at the Growth rate. That is 8.6 and 5.4 times our charge of $0.009716. The deep to advanced match is by purpose. If the two deep calls without full text count as basic, group 1 comes to 8.4 credits, and the multipliers are 6.9 and 4.3.
Group 2 comes to 41.8 credits: $0.3344 on pay-as-you-go and $0.209 at Growth. This compares Tavily's per-page billing with our per-call billing. We did not compare page counts or page content side by side, so we give no multiplier. A fair test would map the same site on both services and compare unique URLs and covered sections. The direction is still clear: site discovery is where Tavily bills grow fastest. The two map calls alone make up 31 credits, about three times all of group 1. For an agent that only searches, the gap is $5 to $8 against $0.694 per 1,000 calls.
Latency is not on the invoice, but it sets agent timeouts:
| Tool | Calls | Latency |
|---|---|---|
map | 2 | 0.44 to 0.80 s |
crawl | 2 | 1.38 s (20 pages), 7.57 s (12 pages, instructions) |
read | 7 | 0.65 to 3.30 s |
deep with full text | 2 | 17.1 to 18.6 s |
deep without full text | 2 | 10.3 s and 48.5 s |
Tavily's advanced Extract has a default timeout of 30 seconds. That value would stop some calls to our deep tool. A timeout costs nothing, but retries slow the task. Give deep retrieval a timeout of about 60 seconds.
If an agent needs only titles and snippets, a single-engine search endpoint costs less. We ran four of them on the same night:
| Endpoint | Time (SGT) | Returned | Charged |
|---|---|---|---|
Bing Scraper API, bing/search | 00:18:02 | 10 results | $0.000556 |
DuckDuckGo Scraper API, duckduckgo/search | 00:20:43 | 10 results | $0.000556 |
Google News Scraper API, google_news/search | 00:29:41 | 20 results | $0.000792 |
Web Search Scraper API, web/search | 00:35:24 | 10 results | $0.001389 |
The platform overviews are on the Bing, DuckDuckGo and web search platform pages. For search alone, our lowest price is $0.556 per 1,000 calls.
Estimating a monthly bill: three agent workloads
Each Tavily endpoint converts work into credits differently. The same budget therefore buys different amounts of work. The volumes below are our assumptions for typical agents. The credit rules come from Tavily's credits page, and each Tavily bill uses the cheapest option at that volume. The EveryInfra column uses the unit prices charged in this test.
Coding agents: 10 developers make 60 lookups each per working day for 22 days. One lookup in five is retried at advanced, so each lookup averages 1.4 credits. Sales research: an agent profiles 2,000 accounts. Each account gets 3 basic searches, a 50-page map and 5 extracted pages, which is 9 credits. News monitoring: 300 topics get one basic search every 6 hours.
| Workload | Tavily credits per month | Cheapest Tavily option | Tavily monthly bill | EveryInfra calls | EveryInfra monthly bill |
|---|---|---|---|---|---|
| Coding agents, 10 developers (20% advanced retries) | 18,480 | Bootstrap + pay-as-you-go | $127.84 | 15,840 | $10.99 |
| Sales research, 2,000 accounts | 18,000 | Bootstrap + pay-as-you-go | $124.00 | 18,000 | $12.49 |
| News monitor, 300 topics every 6 hours | 36,000 | Startup | $220.00 | 36,000 | $24.98 |
The gap is about 9 to 12 times. Retries and site maps push the Tavily bill up. Extract batches of 20 URLs bring Tavily closest to our price. The news monitor also pays for 2,000 credits that it never uses. Model tokens are extra on both sides, and they can cost more than either API bill.
Tavily, Firecrawl, Serper and SerpAPI: billing units side by side
All four vendors bill in credits of some kind, but one credit buys different work. The table shows billing rules only, from pricing pages that we read at 00:25 SGT on 2026-11-18. For the full price comparison per 1,000 calls, see the Tavily alternatives article. For SerpAPI plans, see SerpAPI pricing explained. For Firecrawl options, see Firecrawl alternatives.
| Tavily | Firecrawl | Serper | SerpAPI | EveryInfra | |
|---|---|---|---|---|---|
| Billing unit | credit | credit | query (credit) | search | per call |
| Search | basic 1, advanced 2 | 2 per 10 results | 1 per query | 1 per search | $0.000694 per call |
| Page extraction | 1 per 5 successful URLs (advanced 2) | 1 per page, plus 4 per page for JSON format | none | none | $0.000694 per call |
| Site map | 1 per 10 pages (2 with instructions) | 1 per call | none | none | $0.000694 per call, up to 200 URLs |
| Failures | Extract and Map failures free; empty search not documented | target 403 or 404 still costs 1 | charged only on successful responses | successful searches only; empty results count | failures and empty results free |
| Free allowance | 1,000 per month | 1,000 per month | 2,500 once | 250 per month | trial credit |
| Lowest paid entry | $0.008 per credit, or $30 per month | $19 per month | $50 prepaid pack | $25 per month | per-call from balance |
| Expiry | resets on the 1st | monthly; Scale rolls over 1 month | 6 months | monthly, early renewal | no reset |
Firecrawl charges 1 credit per Map call for any page count, which is the opposite of Tavily's rule. Its MCP v3 came out on 2026-11-12, and the Firecrawl changelog promises "4x more usage". Serper sells four prepaid packs, from $50 for 50,000 queries to $3,750 for 12.5 million. Its FAQ says that only successful responses use credits. SerpAPI plans cost $25 to $275 a month. Its FAQ says that a search with 100 results and a search with none both count as one search.
Because the units differ, convert to the output that you need. Firecrawl search bills per result, and the others bill per call. For extraction, Firecrawl charges for failures and Tavily does not. On sites that block often, the real unit prices therefore move apart. Test your 20 most-used sites on each service and multiply by the success rate.
When Tavily's billing is the better deal
Tavily's billing comes out ahead in these cases:
| Case | Why Tavily fits |
|---|---|
| Under 1,000 basic searches a month | The free plan covers it; keyless mode covers evaluation |
| Students and startup-program teams | Free for students; 100,000 credits for accepted startups |
| 20-URL extract batches with high success | $1.00 per 1,000 URLs at Growth, 1.44 times our read (2.3 times on pay-as-you-go), in one request |
| You want a finished, cited report | Research writes it; we return evidence |
| High concurrency on day one | Pay-as-you-go gives 1,000 searches per minute |
| Heavy existing use of LangChain or Vercel AI SDK Tavily tools | Switching costs engineering time |
| Enterprise procurement needs | Custom limits, SLAs and security terms |
In these cases, free credits, batch throughput or saved engineering time offset the higher unit price. The opposite is true for agents that spend most credits on site maps and crawls. It is also true for teams with large monthly swings. MCP users with auto_parameters on, or with the advanced default from the docs, also pay more than the table suggests. For these workloads, take one month of /usage data and recalculate it with the rules above.
Market moves, October and November 2026
- 2026-11-13: Tavily released
@tavily/cli1.0.0 on npm. Withtvly set-default, every coding-agent lookup spends credits. - 2026-11-13: Firecrawl said Alexandria covers 75 million companies (changelog). More data types mean more credit types to compare.
- November 2026: Tavily rate limits became per organization (changelog). Test loops now share the production limit.
- 2026-11-12: Firecrawl released MCP v3 with "4x more usage" (changelog), and firecrawl-py 4.57.0 came out (PyPI). Price MCP calls as a separate line.
- 2026-11-10: AIMultiple scored Tavily ultra-fast at 26.3% on current-fact questions (AIMultiple). It costs the same as basic but gives less fresh results.
- 2026-10-28: gologin updated its 2026-10-20 review, which measured 10 and 20 credits for 10 basic and 10 advanced queries (gologin). Independent data matches the credits page.
Get started: move one month of Tavily usage over and compare
- Export last month's five usage totals from the Tavily dashboard or
/usage. - Convert the totals to usage with the credits page rules.
/usagegives credits per endpoint but not per depth, so each total becomes a range. The table below shows the rules. - Get a key from the quickstart. Run 50 real queries through
web,deep,read,crawlandmap. - Record
billing.charged_usdfor each call. Tool details are on the search product page. - Add our MCP server and run your agent on the same questions. For tool choice, see how to choose an agent search tool.
- Compare both monthly bills with token usage included. Prices and top-up options are on the pricing page.
The example values in this table come from the sample response in the /usage reference:
| `/usage` field | Example value | Credits page rule | Usage it stands for |
|---|---|---|---|
search_usage | 100 | basic, fast and ultra-fast 1 per call, advanced 2 | 50 to 100 searches |
extract_usage | 25 | basic 1 per 5 successful URLs, advanced 2 per 5; multiply by 5 if all basic, by 2.5 if all advanced | about 62 to 125 successful URLs |
map_usage | 7 | 1 per 10 successful pages, 2 per 10 with instructions; multiply by 10 or by 5 | 35 to 70 pages |
crawl_usage | 15 | Map plus Extract: 3 per 10 pages at basic, 5 at advanced, plus 1 with instructions | about 25 to 50 pages |
research_usage | 3 | mini 4 to 110 per call, pro 15 to 250 | no call count; the sample value 3 is below the mini minimum of 4 |
Extract and Map also accumulate. URLs or pages below the next 5 or 10 are not booked yet, so the totals can miss up to 4 URLs or 9 pages. If your logs record depth and instructions per request, split by log and each range becomes one number. With the sample values, the totals without Research are 147 credits, or $1.18 on pay-as-you-go. That is 50 to 100 searches, about 62 to 125 URLs, one map under 70 pages and 2 or 3 crawls of 20 pages. On EveryInfra, that is 115 to 229 calls, or $0.080 to $0.159.
This is the request from step 3 for a site map. Set $EVERYINFRA_API_KEY to your own key:
curl -s -X POST https://api.everyinfra.com/api/v1/search \
-H "Authorization: Bearer $EVERYINFRA_API_KEY" \
-H "Content-Type: application/json" \
-d '{"tool":"map","params":{"url":"https://docs.tavily.com","num":200}}' \
| jq '{n: (.results|length), charged: .billing.charged_usd}'Related reading: a pricing breakdown of another credit model with multipliers per domain. Firecrawl alternatives covers scraping options.
FAQ
What is Tavily pricing per search? (search suggestion "tavily pricing per search") Basic, fast and ultra-fast searches cost 1 credit each, and advanced costs 2. Pay-as-you-go is $0.008 per credit, so 1,000 basic searches cost $8. At the Growth rate of $0.005, they cost $5. The result count, 10 or 20, does not change the price.
How does Tavily extract pricing work? (search suggestion "tavily extract pricing") Basic extraction costs 1 credit for every 5 successful URLs, and advanced costs 2. Failed URLs are free. The count runs across your account, so one single-URL extraction costs 0.2 credits on average. Per 1,000 URLs, basic costs $1.60 on pay-as-you-go and $1.00 at Growth.
Is the Tavily MCP server free? (search suggestions "tavily mcp pricing" and "is tavily mcp free") MCP has no separate fee. Each tool call uses credits under the rules of the matching endpoint. Keyless mode offers search and extract only, under a fair-use limit, with no credits spent. Check the tool descriptions and DEFAULT_PARAMETERS, because they can move the model to advanced.
Is Tavily free, and is it free for students? (search suggestions "is tavily free" and "is tavily free for students") The free plan gives 1,000 credits a month with no credit card. Credits reset on the 1st, and requests stop when they run out. Student accounts are free, and accepted startups get 100,000 credits. Keyless mode lets you try search and extract without an account.
What is the Tavily API rate limit? (search suggestion "tavily api rate limit") The free plan allows 100 requests per minute. Pay-as-you-go, Project, Bootstrap and Startup allow 1,000, and Growth allows 1,500. Crawl and Map allow 100 per minute, and Research allows 20. Since November 2026, all keys in an organization share the limit.
Is $15 per 1,000 advanced searches a lot? (r/LLMDevs: Tavily vs Search Router) The poster's research agent pays it. That is the Project price for advanced: 2 credits at $0.0075, times 1,000. Growth would cost $10, and pay-as-you-go $16. If the queries do not need advanced, basic halves the cost. EveryInfra deep charged $0.694 per 1,000.
References
- Credits & Pricing, Tavily, read 2026-11-18 00:10 SGT
- Tavily Pricing, Tavily, read 2026-11-18 (including slider tier data)
- Pricing (help center plan article), Tavily, read 2026-11-18
- Tavily Search reference, Tavily, read 2026-11-18
- Tavily Extract reference, Tavily, read 2026-11-18
- Tavily Map reference, Tavily, read 2026-11-18
- Tavily Crawl reference, Tavily, read 2026-11-18
- Tavily Research reference, Tavily, read 2026-11-18
- Usage endpoint reference, Tavily, read 2026-11-18
- Rate Limits, Tavily, read 2026-11-18
- Headers & Authentication, Tavily, read 2026-11-18
- Tavily MCP, Tavily, read 2026-11-18
- Keyless access, Tavily, read 2026-11-18
- Tavily CLI, Tavily, read 2026-11-18
- Best practices for search, Tavily, read 2026-11-18
- Best practices for extract, Tavily, read 2026-11-18
- Best practices for crawl, Tavily, read 2026-11-18
- Changelog, Tavily, read 2026-11-18
- Tavily docs index llms.txt, Tavily, read 2026-11-18
- Tavily for Startups, Tavily, read 2026-11-18
- Student account, Tavily help center, read 2026-11-18
- tavily-mcp source, src/index.ts, GitHub tavily-ai, main branch commit of 2026-11-13, read 2026-11-18
- tavily-mcp repository, GitHub tavily-ai, read 2026-11-18
- tavily-mcp, npm, version 0.2.22 published 2026-08-05
- @tavily/cli, npm, version 1.0.0 published 2026-11-13
- langchain-tavily source, tavily_search.py, GitHub tavily-ai, read 2026-11-18
- tavily-python, PyPI, version 0.8.5 published 2026-10-06
- Tavily in the Claude connector directory, Anthropic, read 2026-11-18
- Tavily Agentic Web Search Certification, Nebius, read 2026-11-18
- Firecrawl Pricing, Firecrawl, read 2026-11-18 00:25 SGT
- Firecrawl Changelog, Firecrawl, latest entry 2026-11-13
- firecrawl-py, PyPI, version 4.57.0 published 2026-11-12
- 5 Tavily Alternatives for Better Pricing, Performance, and Extraction Depth, Firecrawl, updated 2026-10-27
- Serper home page (pricing and FAQ), Serper, read 2026-11-18
- SerpApi Plans and Pricing, SerpApi, read 2026-11-18
- SerpApi Release Notes, SerpApi, latest entry 2026-11-17
- Tavily Review 2026: Search Quality, Formats and Pricing, gologin, published 2026-10-20, updated 2026-10-28
- Agentic Search API Benchmark, AIMultiple, updated 2026-11-10
- Tavily API review: credits, keys and the auto trap, Frontal, read 2026-11-18
- Tavily vs Search Router: looking for advice before scaling our RAG pipeline, Reddit r/LLMDevs, read 2026-11-18
- EveryInfra search tool catalog, EveryInfra, read 2026-11-18 00:16 SGT
- EveryInfra capability catalog, EveryInfra, read 2026-11-18 00:16 SGT
- EveryInfra remote MCP server, EveryInfra, called 2026-11-18 00:29 SGT
Reference BL-184