Tavily API Alternative: Web Search for Agents, Pay per Call

Give your agent live web search without signing up for a search vendor first. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to search the web for "what is an mcp gateway" with tinyfish /search and litescrape /google/search, and give me one table of the URLs each engine returned and which ones appear in both.

One prompt runs a search on two engines and compares them. 1 min setup · 6-15 hrs saved.

You want an agent that can search the web, and the usual first step is to sign up with one search vendor, copy its key into your environment and build around its response shape. Tavily is the vendor most people name for this. This guide shows the other way: one key that reaches several search engines, so you call whichever fits the question and compare when it matters. We ran four of them live on 2026-10-16 with the same query. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to give an agent web search without a Tavily API key?

Monid. Install it once, add one key, and your agent can call a search engine by name with a query and get the results back as typed JSON. Tavily is a search API for AI agents, and it is not in the Monid catalogue; the search engines that are there cover the same job.

• Pay per call. You pay for the searches you run. Octen is $0.001 per call, Litescrape's Google search is $0.00015 per call, MrScraper's Google search is $0.001 per call, and TinyFish search is $0.00 per call (Verified 2026-10-16 with monid inspect). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free.
• One install, every engine. One key and one balance call all of them, and the same key reaches scraping, extraction and the rest of the catalogue when the agent needs the page behind a result.
• Lives inside your agent. Your agent reads SKILL.md and learns discover, inspect and run on its own. Setup is about a minute and nothing stays running between searches.

Look at the web search tools page for the full list of engines.

How do you run one search across several engines on one key?

Pick the engines, inspect each for free, and run the same body against each. Here is the field of options we used.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Step 1. The keyword index with dates

octen/search takes query and count.

monid run -p octen -e /search -i '{"query": "what is an mcp gateway", "count": 10}'

Octen was inspected and not run for this article, because its listed price has a per-token line that applies only when full_content.enable is true. Without that flag it is a flat $0.001 per call (Verified 2026-10-16).

Step 2. The neural index

blockrun.ai/api/v1/exa/search takes query and numResults.

monid run -p blockrun.ai -e /api/v1/exa/search -i '{"query": "what is an mcp gateway", "numResults": 10}'

We ran this once. It returned 10 results and was billed $0.0121 (Verified 2026-10-16).

Step 3. Google, three ways

context.dev/web/search takes numResults from 10 up and bills per result. mrscraper/serp/google takes query, region and language.

monid run -p context.dev -e /web/search -i '{"query": "what is an mcp gateway", "numResults": 10}'
monid run -p mrscraper -e /serp/google -i '{"query": "what is an mcp gateway", "region": "us", "language": "en"}'

Context.dev was inspected and not run: its price is per result at $0.000253 (Verified 2026-10-16), and the smallest search is 10 results. The two GET routes take their parameters with --query:

monid run -p tinyfish -e /search --query '{"query": "what is an mcp gateway"}'
monid run -p litescrape -e /google/search --query '{"q": "what is an mcp gateway", "fast_mode": true}'

We ran MrScraper, TinyFish and Litescrape once each. MrScraper returned 9 organic results in about 4.9 seconds and billed $0.001 (Verified 2026-10-16). TinyFish returned 10 results in about 2.9 seconds and billed nothing. Litescrape returned 9 organic results in about 4.8 seconds and billed $0.00015 (Verified 2026-10-16). The four runs cost $0.01325 in total (Verified 2026-10-16).

Step 4. Diff the URL sets

sets = {name: {normalize(r["url"]) for r in results} for name, results in engines.items()}
shared = set.intersection(*sets.values())

On our four runs shared held one URL, Red Hat's MCP gateway introduction.

📖 See also Brave Search API: what you can keep

Can you build web search for an agent yourself?

Yes, and the work is bigger than the first call suggests. You can scrape a results page, run an open-source metasearch server, or stand up your own crawler and index. The first answer arrives in an afternoon. What follows is the part that costs hours.

Scraping a results page means a fetch layer that survives blocking and CAPTCHAs, a parser that you repair whenever the page markup changes, and a way to cope with the extras around the links (answer boxes, related questions, ads). Running a metasearch server moves that work to someone else's code, and you now host and update it. Building your own index is a crawling project. Rules about what you may fetch and store differ by country and by site, so check the ones that apply to you before you start.

The Monid route is the choice for anything you will run more than once. The fetch, the parsing and the upkeep are maintained for you, each engine returns typed JSON, and a search is a call with a price you can read before you run it. A browser and a hand-written parser stay the better answer when you only need one fixed page, or when search is itself your product.

📖 See also Free web search API for agents

What does a web search API return, and what can you build with it?

A search call returns a ranked list of pages, and the fields around the list differ more than the links do. We ran four engines on 2026-10-16, so the fields below are what came back.

The fields

• Exa through BlockRun. Every row had id, title and url; four rows also carried publishedDate and an author. The body added a costDollars object. One title came back as an empty string.
• Google through MrScraper. Each organic row had link, source, display_link, title, description, rank and global_rank, plus an icon holding a base64 image. Around the rows came people_also_ask with 4 questions, an ai_mode block with text and sections, an empty sponsored array, 6 navigation tabs and a pagination map.
• TinyFish. position, title, url, site_name and snippet on each row, with a date on 8 of the 10.
• Google through Litescrape. Each organic row had position, title, link, displayed_link, source, snippet, snippet_highlighted_words, a base64 favicon, and a date on some. With fast_mode on, no AI Overview block came back.

Octen, from its inspect page, returns title, URL, highlight, authors, publish and crawl times and a favicon, and it can return the full page text; we did not run it.

What you can build with it

• A research agent. Search, then fetch the pages behind the top results. The search call finds the URLs, and the web search tools page shows the extraction endpoints on the same key.
• A question-and-answer tool that cites its sources. Keep the title, url and snippet of each result and put them next to the answer. TinyFish returns exactly those three fields.
• A people-also-ask miner. MrScraper's people_also_ask field returned four related questions for our query. Run it over a list of head terms to build a question list for content.
• A rank check. The rank and position fields give you where a domain sits for a query, as in tracking Google results for an agent.

📖 See also Octen AI Search API

What goes wrong when an agent searches with only one engine?

Four things showed up in our runs on 2026-10-16.

Why do two engines show different pages for one query?

Because they are different indexes, and even the Google-shaped ones differ. Our four engines returned 38 rows and 26 distinct URLs. Only Red Hat's MCP gateway introduction appeared in all of them. MrScraper and Litescrape both read Google and shared exactly that one URL. TinyFish and Litescrape shared two. Exa shared only the Red Hat page with the Google routes, and returned ten pages of its own. An agent on one engine would have called its answer complete.

Why can two providers return the same pages?

Because one index can sit behind two APIs. TinyFish returned the same nine URLs as MrScraper in the same order, then added a tenth, an AWS Builder Center article. When two engines agree that exactly, count them as one opinion and take the second opinion from a different index.

Why is the response bigger than the answer?

Because of what rides along. Both Google routes embedded a base64 image per row for the site icon. Every one of those is text your agent has to carry into its context unless you strip it first. Select the fields you need (title, link, snippet) before the results reach the model.

Why does the price in the body not match the bill?

Because the provider's own accounting is not Monid's. The Exa response said costDollars.total was 0.007; the run was billed $0.0121 (Verified 2026-10-16), which is the price monid inspect lists. Budget from inspect, and treat the figure in the body as the provider's.

📖 See also Google search URL parameters

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect; current figures are on monid.ai/tools. We ran four of the seven; Octen, Keenable and Context.dev were inspected only. For the cheapest first answer, start with TinyFish or Litescrape. For the Google features around the links, take MrScraper. For a second index to compare against, take Exa or Octen.

When is another route a better fit?

You need one vendor's extras. If a single-vendor key also comes with a crawler, a research agent and an extraction API you already use, one account may cost you less effort than several engines. That is a real trade, and it depends on what else you call.

You need the same engine every time. A test suite that compares answers across releases wants one fixed index, not a menu.

Latency dominates. Our four runs took between 2.9 and 4.9 seconds end to end. An interactive agent that cannot wait four seconds should pick the fastest engine for the job and accept its coverage.

You have already measured on your queries. If you ran your own questions through two engines and one kept returning what you needed, use that one. The point of this article is the measurement, not the number of engines.

And the disclosure: this is Monid's blog and Monid sells the endpoints compared here. Tavily is not in the Monid catalogue, so we have not run it and say nothing about how it performs.

📖 See also Bing Search API alternatives

Conclusion

The easiest way to give an agent web search without a Tavily API key is one Monid key and a search endpoint priced per call: $0.00015 for a Google search on Litescrape and $0.00 on TinyFish (Verified 2026-10-16), with the rest of the engines on the same balance. Building your own works for one page and costs hours of fetch and parser upkeep for anything bigger.

Two things matter more than which engine you start with. One engine is one view: our four engines returned 26 distinct URLs across 38 rows and agreed on exactly one. And read the response shape before you build, because the Google routes carried a base64 icon on every row and the cost in a body is not the bill.

How we estimated the time saved: signing up with a search vendor, storing a key, reading its docs and parsing its response shape takes roughly 2 to 5 hours per engine. Three engines is 6 to 15 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p tinyfish -e /search, then send one question you know the answer to through it and litescrape/google/search and diff the URLs. Start at monid.ai.

FAQ

Published September 2026.