Researched: 2026-08-28 03:59 UTC
Scope: What https://monid.ai/blog/tinyfish is, how the underlying service works, and whether it fits this dotfiles/Pi setup.
Yes, it can be integrated, but TinyFish Search/Fetch—not the whole Monid marketplace and not MCP—fits this setup best.
.local/bin/web.py, backed by local SearXNG and trafilatura. TinyFish would be a useful optional backend for JavaScript-heavy pages, fresher search, or pages that ordinary HTTP fetching cannot read.
At retrieval time, monid.ai/blog/tinyfish returned HTML whose title and metadata were “Free search & fetch for every agent”. The rendered page says Monid connects agents to many tools and advertises:
The route appears to fall back to, or currently contain, the Monid homepage. Therefore, the page itself is not reliable as a standalone technical specification. The interpretation below is cross-checked against TinyFish’s official documentation and Monid’s current documentation.
Monid and TinyFish are different products:
discover → inspect → run; a TinyFish capability can be one of the providers in that catalog.
Monid’s marketing page says “no API keys,” while its Skill and API documentation describe API-key authentication. Treat the marketing claim as an abstraction for an agent-integrated flow, not as evidence that programmatic use needs no credentials.
agent or script
|
+--> Search: query -> ranked structured results
+--> Fetch: URLs -> rendered, cleaned page content
+--> Agent: URL + natural-language goal -> browser performs steps -> result
+--> Browser: create cloud Chromium -> Playwright/CDP controls it directly
GET https://api.search.tinyfish.ai accepts a query and optional location, language, domain, date/freshness, and result-type filters. It returns structured result objects containing titles, snippets, URLs, and optional publication metadata.
The official reference documents a default limit of 30 requests/minute per API key. Search is currently free at any wallet balance, but the account still needs Search API access and an X-API-Key header.
POST https://api.fetch.tinyfish.ai accepts up to 10 URLs. TinyFish renders the pages in a real browser, then returns Markdown, semantic HTML, or a JSON document tree. It removes navigation and boilerplate, which is useful as model input and can reduce context size.
Useful controls include:
ttl: 0 for a live fetch;
ttl for acceptable cache age;
include_selectors / exclude_selectors; and
Private IPs, localhost, and cloud-metadata endpoints are rejected. The documented limit is 150 URLs/minute and the backend timeout is up to 110 seconds per URL. Fetch is currently free.
The Agent API takes a target URL plus a natural-language goal, for example “find the current pricing plans and return JSON.” It operates a remote browser, navigates pages, clicks, fills forms, and returns a structured result.
Runs can be:
POST /v1/automation/run;
POST /v1/automation/run-async, then poll GET /v1/runs/{id}; or
POST /v1/automation/run-sse.
Current published pricing is $0.016 per Agent step, charged from a prepaid Wallet. Initial account limits are documented as two concurrent Agent runs and five Browser sessions; higher limits require an account change. Agent runs can expose action logs, screenshots, source URLs, and errors, so prompts and target sites should be treated as observable service data.
The Browser API creates an isolated cloud Chromium session and returns a CDP URL. Existing Playwright, Puppeteer, Selenium, or raw CDP code can connect to it. This is the lower-level option when the user—not TinyFish’s Agent—must own the automation logic.
Published pricing is $0.002 per browser minute, with residential proxy routing and anti-bot handling included according to TinyFish’s product pages. These are vendor claims, and the advertised pass rates are internal testing claims rather than an independent guarantee.
TinyFish distinguishes:
lite or stealth);
The documentation says vault values are not shown to the AI agent or included in prompts, logs, screenshots, or streaming output. That reduces exposure, but it does not remove the fundamental risk of giving a hosted browser access to an account. The Privacy Policy describes broad collection and retention “as long as necessary” without a concrete retention schedule.
Monid’s documented API is a general tool marketplace:
POST /v1/discover searches the catalog for a capability.
POST /v1/inspect returns the selected endpoint’s schema and price.
POST /v1/run executes it, synchronously or asynchronously.
Monid charges endpoint-specific pay-per-use prices from its Wallet. This is useful when the requirement is broader than web access—for example, social-media extraction, enrichment, media generation, or a specialist data provider. It also adds another account, billing layer, provider-selection layer, and data-processing boundary.
For this dotfiles setup, Monid is therefore an optional general-purpose tool marketplace, not the natural replacement for .local/bin/web.py.
Relevant existing pieces:
.local/bin/web.py — current search/fetch command seam;
.pi/agent/skills/web/SKILL.md — instructs Pi to use web.py;
.local/bin/pi.sh — launches Pi in a rootless, read-only Podman container;
setup/pi/Containerfile — defines the tools available inside that image;
setup/packages/npm — versioned global npm tools; and
.config/searxng/ plus the pi-network — existing local search service.
There is no current TinyFish, Monid, or external MCP configuration. Pi does not natively consume a hosted MCP server in this setup; an MCP integration would require an extension/package and authentication handling.
web.pyPreserve the current local default and add TinyFish only when selected or when the local path fails:
web.py search ... # local SearXNG by default
web.py fetch URL # curl + trafilatura by default
web.py --provider tinyfish ... # optional browser-rendered path
The implementation would translate TinyFish’s Search JSON into the existing readable result format and return Fetch’s Markdown directly. This avoids adding a daemon, browser process, MCP server, or a new abstraction layer. It also makes rollback trivial: unset the provider/key and the existing path remains.
The container would need:
The key should not be placed in .config, cron files, prompts, or the dotfiles Git history. Search/Fetch API calls should have explicit timeouts and preserve upstream error details.
TinyFish’s hosted MCP is convenient for Claude/Cursor-like clients, but it is a poor first fit here:
A native Pi extension could be considered later if Agent/Browser actions must appear as first-class tools, but that is more code and more permission surface than this use case requires.
Install Monid separately only if there is a concrete need for its provider catalog. It would require adding the CLI to the Pi image or using its API, persisting its credential configuration across the container boundary, and deciding how to approve paid endpoint runs. For ordinary public research, the existing SearXNG plus direct TinyFish Search/Fetch path is simpler.
Integrate TinyFish Search/Fetch as an opt-in or fallback backend for .local/bin/web.py; do not integrate Monid’s entire marketplace or TinyFish MCP yet. This provides the useful capability—live rendering and clean extraction—while preserving the current local search path, container isolation, and a small operational footprint.