When you wire a web search tool into an agent, the price per 1,000 searches ranges from $0.75 to $35 across eight providers. That 47× spread is not a rounding error. It changes how you design orchestration logic, fallback chains, and quota management.
This article breaks down the pricing structure of 13 web search API tiers, compares standalone APIs against model-native search tools, and explains how cost boundaries influence tool selection at runtime.
The Price Landscape
A recent comparison of official list prices (verified October 27, 2026) reveals two clusters:
Standalone search APIs:
- DeepSeek Search: $0.75 per 1,000 requests
- Perplexity Search (fast): $1.00
- Exa (lite/instant): $4.00
- Brave Search: $5.00
- Tavily: varies by tier
Model-native search tools:
- OpenAI, Anthropic, Google Gemini: $2.00 to $2.80 per 1,000 searches (2× to 2.8× the median standalone API)
The model-native tools bundle search with grounding and citation formatting. Standalone APIs return raw results and leave the synthesis step to your orchestration layer.
All prices exclude model token charges. If your agent calls OpenAI's search tool, you pay for the search request and the tokens generated to summarize results.
Why the Spread Matters for Orchestration
A 47× price difference forces architectural decisions:
Cost-based routing: If your agent handles 10,000 searches per day, the monthly bill ranges from $225 (DeepSeek) to $10,500 (top-tier provider). You can route low-stakes queries to cheap APIs and reserve expensive tiers for queries that need fresh data or specialized indexing.
Quota exhaustion and fallback chains: When the primary API hits rate limits or quota caps, the agent needs a fallback. If your primary is $0.75 per 1,000 and your fallback is $35 per 1,000, a quota spike can blow the budget. You need circuit breakers that track cumulative spend, not just request count.
Result quality vs. cost trade-offs: Cheap APIs may return fewer results per request or lack page content endpoints. If your agent needs full-text extraction, you pay for a separate fetch call. That changes the effective cost per search.
Standalone vs. Model-Native Search Tools
Model-native search tools (OpenAI, Anthropic, Gemini) charge 2× to 2.8× the median standalone API. The premium buys:
- Grounding and citations: The model synthesizes search results into a natural-language response with inline citations. You skip the orchestration step that merges raw results into a prompt.
- Unified billing: One invoice for model tokens and search requests. No separate API keys or quota tracking.
- Latency reduction: The model API fetches search results internally, avoiding a round-trip to a third-party endpoint.
The downside: you lose control over result ranking, filtering, and caching. If your agent needs to inspect raw search results before deciding whether to summarize them, a standalone API gives you that hook.
Architecture: Cost-Aware Tool Selection
Here's a pattern for routing search requests based on cost and query type:
class SearchRouter:
def __init__(self):
self.providers = {
"cheap": {"api": DeepSeekSearch(), "cost_per_k": 0.75, "max_results": 10},
"balanced": {"api": PerplexitySearch(), "cost_per_k": 1.00, "max_results": 20},
"premium": {"api": ExaSearch(), "cost_per_k": 4.00, "max_results": 50},
}
self.monthly_budget = 500.0 # dollars
self.spend_tracker = SpendTracker()
def route(self, query: str, priority: str) -> SearchResult:
# Check remaining budget
if self.spend_tracker.monthly_spend >= self.monthly_budget:
raise QuotaExceededError("Monthly search budget exhausted")
# Route by priority
if priority == "low" and self.spend_tracker.monthly_spend < self.monthly_budget * 0.8:
provider = self.providers["cheap"]
elif priority == "high":
provider = self.providers["premium"]
else:
provider = self.providers["balanced"]
# Execute search
result = provider["api"].search(query)
cost = provider["cost_per_k"] / 1000
self.spend_tracker.record(cost)
return result
This router enforces a monthly budget, routes low-priority queries to the cheapest API, and reserves premium tiers for high-priority requests. The spend tracker logs cumulative cost and blocks requests when the budget cap is hit.
Rate Limits and Fallback Chains
Rate limits vary by provider. DeepSeek and Perplexity publish per-minute and per-day caps. Exa and Brave enforce monthly quotas. When the primary API returns a 429 status, the agent needs a fallback.
Fallback chain design:
- Primary: DeepSeek Search ($0.75 per 1,000, 100 requests/min)
- Secondary: Perplexity Search ($1.00 per 1,000, 200 requests/min)
- Tertiary: Exa Search ($4.00 per 1,000, 500 requests/min)
Each tier has higher cost and higher rate limits. The orchestration layer tracks which tier is active and switches when the current tier returns a rate-limit error.
Circuit breaker logic:
- If the primary API fails three times in a row, open the circuit and route to the secondary for 60 seconds.
- If the secondary also fails, escalate to the tertiary.
- After 60 seconds, close the circuit and retry the primary.
This prevents cascading failures and keeps the agent responsive when one API is down or rate-limited.
Page Content and Fetch Endpoints
Some APIs return search results with snippets. Others offer a separate endpoint to fetch full page content. The cost structure varies:
| Provider | Snippet Included | Page Fetch Endpoint | Fetch Cost (per 1,000) |
|---|---|---|---|
| DeepSeek | Yes | No | N/A |
| Perplexity | Yes | No | N/A |
| Exa | Yes | Yes | $1.00 |
| Brave | Yes | Yes | $2.00 |
| Tavily | Yes | Yes | $3.00 |
If your agent needs full-text extraction, the effective cost per search is the search price plus the fetch price. For Exa, that's $4.00 + $1.00 = $5.00 per 1,000 searches with content. For Brave, it's $5.00 + $2.00 = $7.00.
This changes the cost ranking. DeepSeek is cheapest for snippet-only searches, but if you need full content, Exa becomes competitive.
Free Tiers and Quota Management
Several providers offer free monthly allowances:
- Perplexity: 1,000 free searches per month
- Exa: 500 free searches per month
- Brave: 2,000 free searches per month
If your agent handles fewer than 2,000 searches per month, Brave's free tier covers the entire workload. For higher volumes, you need quota tracking that switches to paid tiers when the free allowance is exhausted.
Quota tracking pattern:
class QuotaTracker:
def __init__(self):
self.free_quota = {"brave": 2000, "exa": 500, "perplexity": 1000}
self.used = {"brave": 0, "exa": 0, "perplexity": 0}
def can_use_free(self, provider: str) -> bool:
return self.used[provider] < self.free_quota[provider]
def record_search(self, provider: str):
if self.can_use_free(provider):
self.used[provider] += 1
else:
# Switch to paid tier
pass
This tracker checks whether the free quota is available before routing a search request. When the quota is exhausted, the router switches to a paid tier or a different provider.
Model-Native Search Tools: When to Use Them
Model-native search tools (OpenAI, Anthropic, Gemini) cost 2× to 2.8× the median standalone API. They make sense when:
- Latency matters: The model API fetches and synthesizes results in one round-trip. No separate API call to a search provider.
- You want grounded responses: The model generates a natural-language answer with inline citations. You skip the orchestration step that merges raw results into a prompt.
- Unified billing simplifies accounting: One invoice for model tokens and search requests. No separate quota tracking or API keys.
They are a poor fit when:
- You need raw search results: If your agent inspects result metadata (URL, snippet, rank) before deciding whether to summarize, a standalone API gives you that control.
- Cost is the primary constraint: Model-native tools are 2× to 2.8× more expensive. If your agent handles high search volume, the premium adds up.
- You want to cache results: Standalone APIs let you cache search results and reuse them across multiple agent runs. Model-native tools bundle search and synthesis, so you can't separate the two.
Failure Modes and Observability
Web search APIs fail in predictable ways:
Rate limit exhaustion: The API returns a 429 status. The agent needs a fallback chain or a retry-with-backoff strategy.
Quota cap: The monthly allowance is exhausted. The agent needs a circuit breaker that blocks requests until the quota resets.
API downtime: The provider's endpoint is unreachable. The agent needs a fallback to a different provider.
Result quality degradation: The API returns low-quality results (spam, outdated content, irrelevant pages). The agent needs a quality filter that discards bad results and retries with a different provider.
Observability hooks:
- Log every search request with provider, cost, latency, and result count.
- Track cumulative spend per provider per day.
- Alert when spend exceeds 80% of the monthly budget.
- Alert when the primary API's error rate exceeds 5% over a 5-minute window.
These hooks let you detect cost overruns and API failures before they break the agent.
Technical Verdict
Use standalone search APIs when:
- Cost is the primary constraint and you handle high search volume.
- You need raw search results for filtering, ranking, or caching.
- You want to route queries to different providers based on query type or priority.
Use model-native search tools when:
- Latency matters and you want grounded responses in one round-trip.
- Unified billing simplifies accounting and you don't need raw result inspection.
- You trust the model's synthesis and citation formatting.
Avoid both when:
- Your agent can answer queries from a local knowledge base or cached data.
- The cost per search exceeds the value of the answer (e.g., low-stakes queries that don't justify a $0.035 search).
The 47× price spread means tool selection is not a one-time decision. It's a runtime routing problem that requires quota tracking, fallback chains, and cost-aware orchestration.
Top comments (0)