web-data-toolkit-mcp

# Web Data Toolkit — MCP server

Four public-data tools for any MCP client: **YouTube transcripts** (one video or a whole channel),
**Google Trends** (interest over time, by region, related queries), and **Google Play reviews**.

Hosted and remote — there is nothing to install, build, or keep running. Point your client at one URL.

```json
{
  "mcpServers": {
    "web-data-toolkit": {
      "type": "http",
      "url": "https://web-data-toolkit.vercel.app/mcp",
      "headers": { "x-api-key": "YOUR_KEY" }
    }
  }
}
```

Clients that accept only a URL can carry the key in the query string instead:
`https://web-data-toolkit.vercel.app/mcp?key=YOUR_KEY`

**Try it before signing up.** Put `wdt_demo_public` in as the key. It is a shared demo key: rate limited,
and capped at 10 rows per call, but every tool answers and you can see the exact shape of the data before
you decide anything.

## Tools

| Tool | What it returns | Required |
|---|---|---|
| `youtube_transcript` | Transcript text for up to 50 videos, with language, an auto-generated flag, word count, title and channel | `url` |
| `youtube_channel_transcripts` | Every recent video of a channel, `@handle` or playlist, each with metadata and transcript — or pass `search: your query` to search YouTube and get the top results with transcripts | `source` |
| `google_trends` | Interest over time, interest by region, and top plus rising related queries for up to 5 keywords | `keyword` |
| `google_play_reviews` | Rating, text, author, thumbs-up, app version and the developer's reply | `app` |

**Question to transcripts in one call.** `{"source": "search: cold plunge recovery", "max": 3}` searches
YouTube and returns the top results with full transcripts, so an agent does not have to know which creator to
ask first.

Optional arguments are described in each tool's input schema, so your client will show them. Full REST
documentation, an OpenAPI specification and an `llms.txt` live at
**<https://web-data-toolkit.vercel.app>**.

## Getting a key

**Start with `wdt_demo_public`.** It is shared, rate limited and capped at 10 rows per call, and every tool
answers on it — enough to see the exact shape of the data.

**For a personal key with higher limits, [open an issue](https://github.com/leekung125/web-data-toolkit-mcp/issues/new)**
and say roughly what volume you need.

⛔ A **RapidAPI** subscription (<https://rapidapi.com/leetanakung98/api/web-data-toolkit>) issues a key for
RapidAPI's own gateway. That key authenticates against *their* endpoint, not this one, so it will not work for
MCP. Subscribe there if you want the REST API billed through RapidAPI; come here for MCP.

## How it behaves

- **Transport:** JSON-RPC 2.0 over Streamable HTTP, protocol `2025-06-18` (it will also negotiate
  `2025-03-26` and `2024-11-05`). The server is stateless: it issues no session id, and `GET` returns 405
  because there is no server-initiated stream.
- **Latency:** every call is a live fetch from the source, not a cache. Measured 2026-09-14, one call each: a
  YouTube transcript in 3.7s, Google Play reviews in 3.8s, a Google Trends keyword in 8.6s, and a whole
  channel of 25 videos with every transcript in 29.8s; the slowest single call that day was 21s. **Set your client timeout to at least 60 seconds.**
- **Built for a context window:** results come back as a reading, not a dump. One Google Trends keyword is
  146 rows and about 37,000 characters of JSON; the MCP answer is around 1,200 characters and says where
  interest sits against the window, the top regions, and the top and rising related queries. Reviews come
  back as a star distribution plus one line each; transcripts as title, channel, language and text. Pass
  `raw: true` on any tool for every field.
- **Large results:** a tool result is truncated at 120,000 characters and says so in its first line, so a
  whole channel cannot silently blow up a context window. Narrow the request for the rest.
- **Errors:** a failed call comes back as an MCP tool result with `isError` set and the reason in the text,
  rather than as a protocol error, so an agent can read and recover from it.

## Honest limits

- Public data only. Nothing behind a login, and no personal data beyond the public author name a platform
  already displays on a review.
- Transcripts are whatever the platform publishes. Auto-generated captions carry the errors the machine made,
  and the response tells you which kind you received.
- Google Trends values are relative interest as Google reports them. They are **not** search volumes.
- There is no published uptime figure, because there is not yet enough history to state one honestly.

## What's in this repo

This is the whole service, not just a manifest.

```
api/mcp.js        the MCP protocol handler - tool listing and tool calls
api/rest.js       the plain REST surface, one handler behind vercel.json rewrites
lib/tools.js      tool definitions and the upstream calls behind them
lib/format.js     row shaping, truncation and the per-call output cap
public/           landing page, openapi.json, llms.txt, robots
vercel.json       the rewrites that map /mcp and /api/* onto the two handlers
server.json       the Model Context Protocol registry manifest
```

Every credential is read from the environment — see `.env.example`. The upstream token is used
server-side only and never reaches a client. The public demo key is rate-limited and row-capped in
`lib/format.js` so an open endpoint can't run up a bill.


## License

MIT — see [LICENSE](LICENSE). The license covers this repository; the hosted service is a separate offering
with its own terms on RapidAPI.