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.

Hand-drawn illustration on paper white: a large glass jar stands in the center with five thin paper slices stacked inside, and a yellow coin drops out of the outlet at its base; around the jar sit a calendar open on its first square, a clock, a magnifier and three small sheets drifting toward the mouth of the jar.

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.

Illustration: a conveyor belt carries blank paper slips into a glass jar one by one; when five translucent slips stack up inside, they turn into one teal coin that drops through the outlet into a tray, while a second small jar holds only two slips and no coin yet. It shows how Extract counts successful URLs and turns every 5 into 1 credit.
Extract credits build up over time: every 5 successful URLs become 1 credit, and until then the meter can read zero. Illustration made for this article

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.

PlanMonthly feeCredits per monthPrice per creditPer 1,000 basic searchesPer 1,000 advanced searchesRequests per minute
Researcher (free)$01,000n/afirst 1,000 freefirst 500 free100
Pay-as-you-gousage onlyn/a$0.008$8.00$16.001,000
Project$304,000$0.0075$7.50$15.001,000
Bootstrap$10015,000$0.00667$6.67$13.331,000
Startup$22038,000$0.00579$5.79$11.581,000
Growth$500100,000$0.005$5.00$10.001,500
Enterprisecustomcustomcustomcustomcustomcustom

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 monthFree credits first: free + pay-as-you-goStrict reading: pay-as-you-go from credit 1Project, overage pay-as-you-goBootstrap, 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.

Grouped bar chart of the monthly bill for each way of buying Tavily credits at six volumes. At 3,000 credits, free plus pay-as-you-go is cheapest at $16, Project $30, Bootstrap $100, Startup $220, Growth $500. At 5,000, free plus pay-as-you-go $32 is cheapest and Project is $38. At 10,000, free plus pay-as-you-go $72, Project $78, Bootstrap $100. At 15,000, Bootstrap $100 is cheapest, free plus pay-as-you-go $112, Project $118. At 40,000, Startup $236 is cheapest, Bootstrap $300, free plus pay-as-you-go $312. At 100,000, Growth $500 is cheapest, Startup $716, Bootstrap $780, free plus pay-as-you-go $792, Project $798. The teal bar marks the cheapest option at each volume.

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 wantTavily parametersCredits per callPer 1,000 pay-as-you-goPer 1,000 at GrowthEveryInfra toolCharged per 1,000
10 snippetsbasic or fast1$8.00$5.00web$0.694
Low-latency snippetsultra-fast1$8.00$5.00web$0.694
Deeper retrievaladvanced2$16.00$10.00deep$0.694
Tavily decidesauto_parameters: true1 to 2$8 to $16$5 to $10n/an/a
Full page textbasic plus include_raw_content1$8.00$5.00deep with full=true$0.694
20 resultsmax_results: 201$8.00$5.00web, 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.

Screenshot of the Tavily Extract and Tavily Map sections of the Tavily credits documentation, with teal boxes around four rules: basic Extract costs 1 credit per 5 successful URL extractions, advanced costs 2; regular Map costs 1 credit per 10 successful pages, Map with instructions costs 2 per 10.
The Extract and Map rules in Tavily's credits documentation: both count successful URLs or pages, and failures cost nothing. Screenshot of the Tavily credits documentation, 2026-11-18 00:38 SGT

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 callTavily basic creditsTavily advanced creditsBasic, pay-as-you-goBasic, GrowthEveryInfra `read`
10.2 (accumulated)0.4 (accumulated)$0.0016$0.0010$0.000694
512$0.0080$0.0050$0.003470
20 (request limit)48$0.0320$0.0200$0.013880
Per 1,000 URLs200400$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.

Horizontal range bar chart on a log scale showing how many credits one Tavily call costs. Search basic 1, search advanced 2, search with auto_parameters 1 to 2, Extract one URL 0.2, Extract 20 URLs basic 4 and advanced 8, Map 50 pages 5, Map 200 pages with instructions 40, Crawl 20 pages basic 6, Crawl 50 pages advanced with instructions 30, Research mini 4 to 110, Research pro 15 to 250. The last four items are teal.

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 creditsResearch calls at the mini ceiling (110)Research calls at the pro ceiling (250)Cheapest case, mini (4)
Free, 1,00094250
Project, 4,00036161,000
Bootstrap, 15,000136603,750
Growth, 100,00090940025,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.

Screenshot of the search_depth parameter definition for the tavily_search tool in tavily-mcp src/index.ts, with a teal box around the description and default: basic for generic results, advanced for more thorough search, use advanced when looking for a specific fact, page or entity, or when basic did not find it; default basic.
The search_depth description in the official Tavily MCP source: the default is basic, but the model is told to switch to advanced when basic did not find it. Screenshot of the GitHub tavily-ai/tavily-mcp source, 2026-11-18 00:40 SGT

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 MCPCallsTavily creditsPay-as-you-goGrowth
Default basic searchtavily_search1$0.008$0.005
DEFAULT_PARAMETERS set as in the docs exampletavily_search (forced to advanced)2$0.016$0.010
Basic finds nothing, retry at advancedtavily_search x23$0.024$0.015
Search, then extract the top 3 resultstavily_search + tavily_extract1.6$0.0128$0.008
Site crawl with defaults, runs to 50 pagestavily_crawl15$0.12$0.075
Hand it to research, model=autotavily_research4 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:

bash
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.

Grouped bar chart of the real price per credit on Tavily's four paid plans at different usage levels, with a dashed line at the $0.008 pay-as-you-go rate. Project: full use $0.0075, 75% $0.0100, 50% $0.0150, 25% $0.0300. Bootstrap: $0.0067, $0.0089, $0.0133, $0.0267. Startup: $0.0058, $0.0077, $0.0116, $0.0232. Growth: $0.0050, $0.0067, $0.0100, $0.0200. The 50% bars are teal.

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:

CodeMeaningAgent responseExtra cost
429Rate limit hitWait for Retry-After, then resendNone
432Key or plan credit limit reachedStop and report to a person; resending will not helpNone
433Your pay-as-you-go cap reachedStop; a person decides whether to raise the capNone
434Free tier "Flex tier capacity exceeded" with max_age_hoursDrop max_age_hours and accept cached resultsNone

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:

bash
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".

Screenshot of two real EveryInfra search responses. Top: the 422 at 00:28:51, error code unknown_param, did_you_mean q, allowed parameters after, before, location, num, page, q and site, and next_steps saying Nothing was charged. Bottom: the empty result at 00:29:03, with billing charged false, charged_usd 0.0 and reason empty_result_refunded; the balance is masked. Teal boxes mark did_you_mean, next_steps, charged_usd and reason.
A Tavily-style parameter name gets a 422 pointing to q, and an empty result costs $0. Screenshot of EveryInfra API responses, 2026-11-18 00:28 and 00:29 SGT

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 toolReturnedChargedSame work in Tavily credits
00:17:29web10 results$0.0006941
00:19:06deep5 results$0.0006942
00:19:29read1 page$0.0006940.2
00:26:37deep5 results$0.0006942
00:27:34deep full5 full pages$0.0006941
00:27:59 to 00:28:39read x55 pages$0.0034701
00:29:31MCP everyinfra_search to web10 results$0.0006941
00:34:20web10 results$0.0006941
00:34:30deep full5 full pages$0.0006941
00:34:57read1 page$0.0006940.2
Group 1 subtotal: search and Extract14 calls$0.00971610.4
00:19:42map docs.tavily.com110 URLs$0.00069411 (by page count)
00:20:26crawl with instructions12 pages$0.0006944.8 (by page count)
00:35:05crawl20 pages$0.0006946 (by page count)
00:35:15map docs.firecrawl.dev200 URLs$0.00069420 (by page count)
Group 2 subtotal: site maps and crawls4 calls$0.00277641.8
00:35:34crosscheck (group 3)four methods agree$0.002778not converted
Total19 calls$0.015270n/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.

Horizontal range chart on a log scale of the dollar price per 1,000 calls. Grey bars show Tavily from the Growth rate to pay-as-you-go: basic search $5 to $8, advanced search $10 to $16, extract one URL $1.00 to $1.60, extract five URLs $5 to $8, crawl 20 pages $30 to $48, map 200 URLs $100 to $160, research minimum $20 to $32. Teal dots show EveryInfra charges: web, deep, read, crawl and map at $0.694, read five times at $3.47, crosscheck at $2.78.

Latency is not on the invoice, but it sets agent timeouts:

ToolCallsLatency
map20.44 to 0.80 s
crawl21.38 s (20 pages), 7.57 s (12 pages, instructions)
read70.65 to 3.30 s
deep with full text217.1 to 18.6 s
deep without full text210.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:

EndpointTime (SGT)ReturnedCharged
Bing Scraper API, bing/search00:18:0210 results$0.000556
DuckDuckGo Scraper API, duckduckgo/search00:20:4310 results$0.000556
Google News Scraper API, google_news/search00:29:4120 results$0.000792
Web Search Scraper API, web/search00:35:2410 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.

WorkloadTavily credits per monthCheapest Tavily optionTavily monthly billEveryInfra callsEveryInfra monthly bill
Coding agents, 10 developers (20% advanced retries)18,480Bootstrap + pay-as-you-go$127.8415,840$10.99
Sales research, 2,000 accounts18,000Bootstrap + pay-as-you-go$124.0018,000$12.49
News monitor, 300 topics every 6 hours36,000Startup$220.0036,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.

TavilyFirecrawlSerperSerpAPIEveryInfra
Billing unitcreditcreditquery (credit)searchper call
Searchbasic 1, advanced 22 per 10 results1 per query1 per search$0.000694 per call
Page extraction1 per 5 successful URLs (advanced 2)1 per page, plus 4 per page for JSON formatnonenone$0.000694 per call
Site map1 per 10 pages (2 with instructions)1 per callnonenone$0.000694 per call, up to 200 URLs
FailuresExtract and Map failures free; empty search not documentedtarget 403 or 404 still costs 1charged only on successful responsessuccessful searches only; empty results countfailures and empty results free
Free allowance1,000 per month1,000 per month2,500 once250 per monthtrial credit
Lowest paid entry$0.008 per credit, or $30 per month$19 per month$50 prepaid pack$25 per monthper-call from balance
Expiryresets on the 1stmonthly; Scale rolls over 1 month6 monthsmonthly, early renewalno 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:

CaseWhy Tavily fits
Under 1,000 basic searches a monthThe free plan covers it; keyless mode covers evaluation
Students and startup-program teamsFree 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 reportResearch writes it; we return evidence
High concurrency on day onePay-as-you-go gives 1,000 searches per minute
Heavy existing use of LangChain or Vercel AI SDK Tavily toolsSwitching costs engineering time
Enterprise procurement needsCustom 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/cli 1.0.0 on npm. With tvly 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

  1. Export last month's five usage totals from the Tavily dashboard or /usage.
  2. Convert the totals to usage with the credits page rules. /usage gives credits per endpoint but not per depth, so each total becomes a range. The table below shows the rules.
  3. Get a key from the quickstart. Run 50 real queries through web, deep, read, crawl and map.
  4. Record billing.charged_usd for each call. Tool details are on the search product page.
  5. Add our MCP server and run your agent on the same questions. For tool choice, see how to choose an agent search tool.
  6. 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` fieldExample valueCredits page ruleUsage it stands for
search_usage100basic, fast and ultra-fast 1 per call, advanced 250 to 100 searches
extract_usage25basic 1 per 5 successful URLs, advanced 2 per 5; multiply by 5 if all basic, by 2.5 if all advancedabout 62 to 125 successful URLs
map_usage71 per 10 successful pages, 2 per 10 with instructions; multiply by 10 or by 535 to 70 pages
crawl_usage15Map plus Extract: 3 per 10 pages at basic, 5 at advanced, plus 1 with instructionsabout 25 to 50 pages
research_usage3mini 4 to 110 per call, pro 15 to 250no 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:

bash
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

  1. Credits & Pricing, Tavily, read 2026-11-18 00:10 SGT
  2. Tavily Pricing, Tavily, read 2026-11-18 (including slider tier data)
  3. Pricing (help center plan article), Tavily, read 2026-11-18
  4. Tavily Search reference, Tavily, read 2026-11-18
  5. Tavily Extract reference, Tavily, read 2026-11-18
  6. Tavily Map reference, Tavily, read 2026-11-18
  7. Tavily Crawl reference, Tavily, read 2026-11-18
  8. Tavily Research reference, Tavily, read 2026-11-18
  9. Usage endpoint reference, Tavily, read 2026-11-18
  10. Rate Limits, Tavily, read 2026-11-18
  11. Headers & Authentication, Tavily, read 2026-11-18
  12. Tavily MCP, Tavily, read 2026-11-18
  13. Keyless access, Tavily, read 2026-11-18
  14. Tavily CLI, Tavily, read 2026-11-18
  15. Best practices for search, Tavily, read 2026-11-18
  16. Best practices for extract, Tavily, read 2026-11-18
  17. Best practices for crawl, Tavily, read 2026-11-18
  18. Changelog, Tavily, read 2026-11-18
  19. Tavily docs index llms.txt, Tavily, read 2026-11-18
  20. Tavily for Startups, Tavily, read 2026-11-18
  21. Student account, Tavily help center, read 2026-11-18
  22. tavily-mcp source, src/index.ts, GitHub tavily-ai, main branch commit of 2026-11-13, read 2026-11-18
  23. tavily-mcp repository, GitHub tavily-ai, read 2026-11-18
  24. tavily-mcp, npm, version 0.2.22 published 2026-08-05
  25. @tavily/cli, npm, version 1.0.0 published 2026-11-13
  26. langchain-tavily source, tavily_search.py, GitHub tavily-ai, read 2026-11-18
  27. tavily-python, PyPI, version 0.8.5 published 2026-10-06
  28. Tavily in the Claude connector directory, Anthropic, read 2026-11-18
  29. Tavily Agentic Web Search Certification, Nebius, read 2026-11-18
  30. Firecrawl Pricing, Firecrawl, read 2026-11-18 00:25 SGT
  31. Firecrawl Changelog, Firecrawl, latest entry 2026-11-13
  32. firecrawl-py, PyPI, version 4.57.0 published 2026-11-12
  33. 5 Tavily Alternatives for Better Pricing, Performance, and Extraction Depth, Firecrawl, updated 2026-10-27
  34. Serper home page (pricing and FAQ), Serper, read 2026-11-18
  35. SerpApi Plans and Pricing, SerpApi, read 2026-11-18
  36. SerpApi Release Notes, SerpApi, latest entry 2026-11-17
  37. Tavily Review 2026: Search Quality, Formats and Pricing, gologin, published 2026-10-20, updated 2026-10-28
  38. Agentic Search API Benchmark, AIMultiple, updated 2026-11-10
  39. Tavily API review: credits, keys and the auto trap, Frontal, read 2026-11-18
  40. Tavily vs Search Router: looking for advice before scaling our RAG pipeline, Reddit r/LLMDevs, read 2026-11-18
  41. EveryInfra search tool catalog, EveryInfra, read 2026-11-18 00:16 SGT
  42. EveryInfra capability catalog, EveryInfra, read 2026-11-18 00:16 SGT
  43. EveryInfra remote MCP server, EveryInfra, called 2026-11-18 00:29 SGT

Reference BL-184

Google Analytics needs consent. Privacy