tinyfish-web-mcp
Use two MCP tools to search the live web and read pages as clean markdown, backed by TinyFish (free at any wallet balance).
web_searchreturns up to 10 ranked results with title, URL, snippet; news adds date/publisher, papers add authors/venue/citations.Search can be narrowed by
domain_type(web,news,research_paper),recency_minutes, comma-separatedinclude_domains/exclude_domains, and optionalpurpose.web_fetchreads 1–10 URLs as clean markdown with JavaScript rendered.Long pages support pagination via
offset; each URL returns at most 20,000 characters per call.Both tools return structured content for scripts;
web_fetchincludes pages, errors, andnext_offset; checkisErroron failures.Do not use it for JSON/raw files because markdown conversion can alter structured data.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@tinyfish-web-mcpsearch the web for recent advances in quantum computing"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
tinyfish-web-mcp
A lean MCP server that gives any agent two tools, web_search and web_fetch, backed by TinyFish's Search and Fetch APIs. Both APIs are free at any wallet balance.
Unofficial. TinyFish also runs an official remote MCP server with around 15 tools, including paid browser automation. This server exposes only search and fetch, so it costs about 2 KB of tool schema in your agent's context.
Tools
web_search: searches the live web and returns up to 10 ranked results (title, URL, snippet). News results add date and publisher; research papers add authors, venue and citation count.
Input | Description |
| Search keywords |
|
|
|
|
| Arrays of domains to limit results to or exclude |
web_fetch: reads 1–10 URLs as clean markdown, with JavaScript rendered.
Input | Description |
| URLs to read (1–10) |
One call returns at most about 19 KiB of text, so it fits under client output limits (pi cuts MCP output at 20 KiB, Claude Code at about 25k tokens) and no page's file path gets cut. A single page shows up to about 19,000 characters inline (fewer for CJK text, which takes 3 bytes per character). When several URLs share a call, short pages are returned whole and the rest split what's left. A page that doesn't fit is downloaded once and saved in full to a markdown file under $TMPDIR/tinyfish-web-mcp/. Its result header gives the file path and an outline of the page's headings with line numbers, so the agent can Grep the file or Read just the section it needs, with no more network calls:
[truncated: showing lines 1–160 of 5295 (446095 chars). Full markdown saved to /tmp/tinyfish-web-mcp/2cb5….md — Grep it or Read a line range for the rest]
Outline (line: heading):
25: ## 1. Introduction
1214: ## 8. Representation Data and Metadata
…The note and outline sit before the page text, so they survive clients that truncate long tool output. The outline is capped at about 3,000 characters (deeper heading levels are dropped first). Lines longer than 1,000 characters are wrapped in the saved file so file-reading tools don't cut them. Saved files are private to the current user, re-fetching a URL overwrites its file, and every web_fetch call deletes files older than 24 hours and the oldest files beyond 100 MB in total.
Both tools return readable text plus structuredContent for scripts (for example pi's codemode): web_search gives results[{title, url, snippet, ...}], web_fetch gives pages[{url, title, text, total_chars, truncated?}] and errors. truncated is present only for long pages and holds {path, outline[{line, level, title}], omitted_headings, shown_lines, total_lines}. A call fails with isError: true when it errors, or when every URL of a web_fetch fails; clients that run tools from scripts get that as a normal result, so check isError. TinyFish returns no results for domain_type: "news" combined with exclude_domains, and rejects recency with research_paper.
Markdown conversion can alter structured data; for example, it escapes _ in JSON keys. Fetch JSON and raw files with a plain HTTP client instead.
Related MCP server: sofya-mcp
Install
Create an API key at agent.tinyfish.ai/api-keys. The server reads it from TINYFISH_API_KEY. Requires Node.js 20 or later.
Claude Code
claude mcp add tinyfish-web -s user -e TINYFISH_API_KEY=sk-tinyfish-... -- npx -y @kky42/tinyfish-web-mcpCodex
codex mcp add tinyfish-web --env TINYFISH_API_KEY=sk-tinyfish-... -- npx -y @kky42/tinyfish-web-mcpOther MCP clients (Cursor, Claude Desktop, and others that use this JSON format)
{
"mcpServers": {
"tinyfish-web": {
"command": "npx",
"args": ["-y", "@kky42/tinyfish-web-mcp"],
"env": { "TINYFISH_API_KEY": "sk-tinyfish-..." }
}
}
}Pi has built-in MCP support. Add this to ~/.pi/agent/mcp.json and run pi mcp list to check it. With the default exposure the tools are reached from codemode scripts as tools.mcp__tinyfish_web__web_search and tools.mcp__tinyfish_web__web_fetch; add "exposure": "direct" to declare them to the model like built-in tools.
{
"mcpServers": {
"tinyfish-web": {
"command": "npx",
"args": ["-y", "@kky42/tinyfish-web-mcp"]
}
}
}If TINYFISH_API_KEY is exported in your shell, pi passes it to the server.
Development
npm install
npm run test:e2e # build + real MCP client over stdio against the live TinyFish APIs (needs TINYFISH_API_KEY)License
MIT
Available Tools
2 toolsweb_fetchWeb FetchARead-only
Read web pages as clean markdown, with JavaScript rendered. Up to 10 URLs per call. Each URL returns at most 20000 characters; a truncated page's header gives the offset to continue from. Markdown conversion can alter structured data (e.g. it escapes _ in JSON keys), so fetch JSON or raw files with a plain HTTP client instead.
| Name | Required | Description | Default |
|---|---|---|---|
| urls | Yes | URLs to read (1–10). | |
| offset | No | Character position to start from, applied to every URL. Default 0. To continue a truncated page, use the offset from its header note. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint and openWorldHint, so the description carries the rest and does it well: JS rendering, the 10-URL batch ceiling, the 20000-character per-URL cap, the truncation/offset continuation workflow, and a real behavioral caveat that markdown conversion mutates structured data such as underscores in JSON keys.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, each doing distinct work: capability, batch limit, per-URL limit plus continuation, and the misuse caveat. The core capability is front-loaded and nothing is redundant with the schema beyond necessary reinforcement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description still tells the agent what comes back (clean markdown per URL) and how to interpret and extend a partial result via the truncation header and offset. Nothing needed to invoke this correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so a baseline of 3 applies, but the description goes beyond the schema by explaining the functional relationship between the two parameters: each URL is truncated at 20000 characters and the offset parameter is how you continue from the header note. That adds workflow meaning the schema fields only hint at.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Read web pages as clean markdown, with JavaScript rendered') and immediately differentiates itself from the sibling web_search by describing a direct-read rather than discovery operation. An agent can tell which of the two tools to reach for without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives an explicit when-not-to-use case plus the alternative: 'fetch JSON or raw files with a plain HTTP client instead', justified by markdown conversion escaping characters. That is a concrete routing rule with a stated reason, not just an implied context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_searchWeb SearchARead-only
Search the live web. Returns up to 10 ranked results (title, URL, snippet; plus date and publisher for news, authors/venue/citations for papers). Use it to find URLs, then read them with web_fetch.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search keywords. Supports site: and -site: operators. | |
| purpose | No | One sentence on why you're searching; improves ranking. | |
| domain_type | No | Result type (default web). | |
| exclude_domains | No | Comma-separated domains to exclude, e.g. pinterest.com,quora.com. | |
| include_domains | No | Comma-separated domains to limit results to, e.g. github.com,arxiv.org. | |
| recency_minutes | No | Only results from the last N minutes (e.g. 1440 = 1 day, 10080 = 1 week). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations cover the safety profile (readOnlyHint, openWorldHint), so the bar is lower. The description adds genuinely useful behavior beyond that: the result cap ('up to 10'), the returned fields, and the enrichment for news and papers. It omits anything about ranking behavior or result variability, keeping it below 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. The outcome (what you get back) is front-loaded before the follow-up workflow.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description usefully characterizes the return payload, and the schema fully covers inputs. Nothing needed to invoke the tool correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all six parameters including operators, enums, and recency units. The description adds no parameter detail beyond what the schema already provides, which is the correct baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Search the live web') and immediately distinguishes itself from its only sibling by describing the find-then-fetch workflow. An agent can tell web_search from web_fetch without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly names the alternative ('read them with web_fetch'), giving a clear two-step workflow. It does not state when NOT to use this tool (e.g., for content already fetched), but the routing guidance is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
v0.1.0- First observed
web_fetch - First observed
web_search
TDQS
Scored across 2 tools
web_search finds URLs while web_fetch reads them, with no overlap in purpose. The descriptions explicitly link them as a sequential workflow, making selection unambiguous.
Both tools follow a clean web_<verb> snake_case pattern. There is no deviation or ambiguity in naming style.
Two tools is thin for a general web-access server, even if they are powerful. The surface feels minimal, and the rubric treats 1-2 tools as borderline.
The search-and-fetch pair covers the core web retrieval lifecycle, including pagination via offset. Minor gaps exist, such as no dedicated extraction or structured-data tool, but the provided descriptions explain workarounds.
Maintenance
Related MCP Connectors
LLM-ready web search + instant answers + URL-to-clean-text fetch for agents and RAG.
Agent-native search engine with live web research optimized for AI agents.
Web search, fetch, extract, and research for AI agents. Markdown output + AI-synthesized answers.
Live web access for agents: scrape, SERP search, crawl/map, 100+ collectors, datasets, proxies.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to perform query-driven web searches and fetch page content via Bing and DuckDuckGo engines, with automatic fallback and no API keys needed.MIT
- AlicenseAqualityCmaintenanceWeb tools for AI agents. Search the web for full page content, fetch URLs as clean markdown including PDFs, extract structured data from a page with a prompt, and run multi-source deep research that returns a cited report.42MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to perform web searches, extract webpage content, and conduct end-to-end search-and-extract operations using multiple search providers and content extraction methods.-
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to search the web and extract content using multiple search providers, with caching, retry logic, and options for JavaScript-heavy page rendering.-