Bitdoze logo

Give Muse AI Better Web Search: Free TinyFish Search + Fetch Setup

Muse already browses the web, but every lookup burns tokens on raw HTML. Here's how to wire TinyFish's free Search + Fetch API into Muse's VM for cleaner, cheaper web access.

Dragos

10 min read

Give Muse AI Better Web Search: Free TinyFish Search + Fetch Setup

Muse ships with its own browser and web search, so on paper it doesn’t need help finding things online. In practice I kept hitting the same friction: every page it opened came back as a heavyweight browser session, and since Muse meters everything in tokens, sloppy web access is real money leaking out of your billion-token runway.

The fix is the same one I use for my coding agents: TinyFish, a free Search + Fetch API that returns clean JSON and markdown instead of raw HTML. The difference with Muse is that you don’t wire anything yourself — every Muse account sits on a real Linux VM, and when I asked it to add TinyFish it built the connector, collected the key through a secure form, and verified both endpoints with live calls. Here’s what happened, and the extras worth adding on top.

What you need

  • A Muse account — if you don’t have one yet, my Muse invite guide covers signup and a 1-billion-token invite code
  • A free TinyFish API key from agent.tinyfish.ai — no credit card
  • About five minutes inside Muse’s chat

Why bother when Muse already browses

Muse’s built-in browser is a real Chromium on its VM. It’s genuinely good at interactive work — signing into sites, filling forms, clicking through checkout flows. But for the everyday case of “look something up and read a page,” it’s overkill, and it costs more than it should:

  • Token burn. A browser-rendered page carries navigation, cookie banners, script tags, and layout markup. Muse reads all of it. TinyFish Fetch strips the boilerplate server-side and returns just the content as markdown, so the agent spends tokens on the article instead of the chrome.
  • Structured search. Muse’s search returns what a person needs — links to click. TinyFish Search returns rank-stable JSON with titles, snippets, and URLs that an agent can reason over directly, without a browser step in between.
  • Headroom. The free tier is 30 searches and 150 fetches per minute. That’s far more than one personal agent will ever use, and it doesn’t touch your Muse token balance at all.

There’s a second reason that’s less obvious. Muse runs Goals — long-running objectives it works on a schedule — and tracked items like prices and deliveries. TinyFish recently shipped Monitor, which does exactly that on the web side: watch a page or a topic on a schedule, get told when it changes. Pairing the two means the scheduled job is cheap (TinyFish diffs the page) and the reasoning about what changed stays with Muse.

Setting it up: just ask Muse

Here’s the part that surprised me when I actually did it: you don’t install anything by hand. Every Muse account sits on a real Linux VM and Muse can build its own tools on it, so the whole setup is one message. I asked it verbatim:

text
How can we add TinyFish for search and fetch in you?
They have an MCP and CLI with API key.

Muse went off and read TinyFish’s cookbook repo itself, weighed the three options (MCP server, the @tiny-fish/cli package, plain REST), and picked REST as the cleanest fit — both endpoints are free and one key covers both. Then it did something I didn’t prompt: it rendered a TinyFish Connector card in the chat with a Connect button. Clicking it opens a secure form where the key goes straight into encrypted storage — it never passes through the conversation. No pasting secrets into chat, no .bashrc fiddling.

After connecting, Muse proved the wiring with live calls on the spot: a search for “TinyFish web agent” came back as ranked JSON with titles, URLs, and snippets, and fetching tinyfish.ai returned the full page as clean markdown in about half a second. It saved the result as a reusable connector plus a small skill — the same search-first-then-fetch escalation rule I’d want it to follow anyway — so from then on it reaches for TinyFish whenever a task needs live web grounding.

Two details from the actual run worth knowing: Fetch batches up to 10 URLs per call, and only the free Search and Fetch endpoints got wired up — the metered Agent/Browser automation endpoints stay unregistered unless you ask for them, which is the right default.

Use the Connect form, not the chat

If Muse offers a connector card, always enter keys through it — that path writes to encrypted storage directly. If you ever do paste a key into a message for some reason, follow up by telling Muse to move it to the vault and not print it again. TinyFish keys are free and rotatable, so the stakes are low, but the habit is cheap.

Optional: pin the behavior in memory

The connector Muse built already persists across sessions, but if you want the escalation rule spelled out explicitly, add a section to Muse’s editable Memory — the same memory files I covered in the Muse overview:

markdown
## Web access via TinyFish

Use TinyFish instead of the browser for reading pages and searching.
- Search: GET https://api.search.tinyfish.ai?query=<query>
  with header `X-API-Key` — returns ranked JSON results.
- Fetch: POST https://api.fetch.tinyfish.ai with JSON body
  {"urls": ["<url>"]} — returns clean markdown, up to 10 URLs per call.

Prefer search+fetch for docs, news, and lookups. Use the browser only
when a page needs clicking, login, or JavaScript interaction.

That last line is the important part. Without it, Muse reaches for the browser out of habit. With it, the agent has an explicit rule: cheap API first, real browser only when a page actually needs interaction.

Scheduled watching: TinyFish Monitor + Muse Goals

This is the combination I didn’t expect to like as much as I do. Muse Goals already revisit objectives on a schedule, and TinyFish Monitor watches a URL or search topic and reports diffs — new content on a pricing page, new results for a query. Two ways to use them together:

  • Standalone Monitor. Create the watch in the TinyFish dashboard or over its REST API, point the webhook or email result at yourself, and let Muse reason about changes when you paste or forward them. Each run costs $0.005 plus the underlying fetch, which counts against the free daily allowance — a daily watch is roughly $0.15 a month.
  • Muse-driven. Ask Muse to create and manage monitors through the REST API as part of a Goal: “monitor this changelog weekly and summarize what changed.” Muse keeps the schedule and the judgment, TinyFish does the cheap fetching.

The second pattern is where Muse’s model shines — the agent decides whether a change matters, TinyFish just does the repetitive watching for a fraction of a cent.

Deeper questions: the Research API

Muse has its own multi-source deep research, and it’s good. The TinyFish Research API (in beta, open to all accounts) is a useful second opinion: you POST a natural-language question to https://agent.tinyfish.ai/v1/automation/run-research and it streams back a synthesized report with citations. Ask Muse to run it with curl when a question deserves more than one search:

bash
curl --no-buffer https://agent.tinyfish.ai/v1/automation/run-research \
  -H "X-API-Key: $TINYFISH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "your question here", "mode": "deep"}'

Two research engines disagreeing is more informative than one being confident. When Muse’s own research and a TinyFish report land on the same conclusion, I trust it. When they don’t, the citations tell me which source actually said what.

Practical prompts to try

  • “Use TinyFish to search for the current Astro content collections API and fetch the two most relevant docs pages.”
  • “Fetch this GitHub issue thread with TinyFish and tell me if my error is the same one described.”
  • “Search TinyFish for ‘GLM coding plan pricing’ and give me the numbers with sources.”
  • “Create a TinyFish monitor on this changelog URL, check it daily, and brief me when a version ships.”
  • “Run a TinyFish deep-research query on <topic> and compare it with your own research — flag where they disagree.”

What works and what doesn’t

What works: Fetch is the clear win — clean markdown, fast, free, and noticeably cheaper on tokens than letting the browser chew through a docs site. Setup turned out to be a single message: Muse built the connector itself, ran live verification calls, and saved it as a reusable skill. Monitor is a natural fit for Goals, and the free tier is effectively unlimited for one agent.

What doesn’t: Search results can lag a few minutes behind breaking news — same caveat as every search API. The browser is still required for anything behind a login, anything interactive, and anything where Muse needs to act rather than read. And the Research API is beta: fine for second opinions, I wouldn’t build a workflow on it yet.

FAQ

Does using TinyFish inside Muse cost extra?

No. TinyFish Search and Fetch are free at 30 requests/minute and 150 URLs/minute respectively, and the calls run on TinyFish’s infrastructure — Muse spends only the small number of tokens it takes to issue the request and read the clean result. Monitor runs cost $0.005 each plus the underlying fetch.

Is my TinyFish API key safe with Muse?

Reasonably safe, if you use the vault. Muse’s credentials vault is designed so the agent can use secrets without being able to echo them back, and sensitive outbound actions go through an approval step. That said, a TinyFish key is free and revocable — if it ever leaked, you’d rotate it in ten seconds, so this isn’t a high-stakes secret.

Why not just let Muse use its own browser for everything?

You can, and for interactive pages you should. The argument is cost and cleanliness for the read-only majority of lookups: TinyFish returns the article text, not a rendered page full of markup, which means fewer tokens spent per lookup and less noise for the model to wade through.

Does this work on Muse's mobile app or WhatsApp?

Yes, indirectly. The TinyFish CLI and credentials live on your Muse VM, not on a device. Anything you ask from mobile, WhatsApp, or the web app executes on the same VM, so once it’s set up it works from every surface.

Bottom line

Muse’s browser is for acting on the web; TinyFish is for reading it cheaply. Setup was one message — Muse built the connector, stored the key through its secure form, and saved a search-first-then-fetch skill — and the free tier means the whole arrangement costs nothing beyond a few Muse tokens per lookup. If you’re running Goals or tracked items, add a Monitor and let TinyFish do the watching.

Get a free TinyFish API key
#Muse#TinyFish#AI Agents

Related Posts