tinyfish-web-mcp
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; supports |
| One sentence on why you're searching; improves ranking |
|
|
| Only results from the last N minutes |
| Comma-separated domain filters |
web_fetch: reads 1–10 URLs as clean markdown, with JavaScript rendered.
Input | Description |
| URLs to read (1–10) |
| Character position to start from, applied to every URL (default 0) |
Each URL returns at most 20,000 characters. For a longer page, the result header names the exact follow-up call, for example offset 20000, so the agent reads the next part instead of starting over. The note sits before the page text, so it survives clients that truncate long tool output. Every call downloads the whole page again, because TinyFish has no range requests.
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, via pi-mcp-adapter. Run pi install npm:pi-mcp-adapter, then add this to ~/.pi/agent/mcp-adapter.json. directTools and toolPrefix: "none" make the tools appear as plain web_search and web_fetch:
{
"mcpServers": {
"tinyfish-web": {
"command": "npx",
"args": ["-y", "@kky42/tinyfish-web-mcp"],
"directTools": true,
"toolPrefix": "none"
}
}
}If TINYFISH_API_KEY is exported in your shell, pi passes it to the server.
Development
npm install
npm test # build + unit tests
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.
Web data tools for AI agents: pages as markdown, search, maps, commerce, jobs, AI answers.
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
- AlicenseAqualityDmaintenanceWeb 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.41MIT
- 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 gradedqualityCmaintenanceEnables AI agents to search the web and extract content using multiple search providers, with caching, retry logic, and options for JavaScript-heavy page rendering.-