Google Trends MCP
This server gives you 11 raw market-research data tools you can call from any MCP client to check demand, competition, trends, and community sentiment before committing to an idea.
Google Trends: compare up to 5 keywords over time (
interest_over_time), see top/rising related queries (related_queries) and topics (related_topics), and break down interest by region/country (interest_by_region).Reddit: search what people are actually saying, asking, or complaining about, with optional subreddit filtering (
reddit_signal).News: gauge press coverage and its angle over the last week/month/year (
news_coverage).Wikipedia: pull monthly pageview counts as a reading-interest signal (
wikipedia_pageviews).Builder activity: check Hacker News stories and GitHub repos to see who is shipping in a space (
builder_activity).App Store: find existing apps, their ratings, rating counts, prices, and update recency (
app_store_apps).YouTube: see how much people watch content about a topic, with views, likes, and comments (
youtube_videos).Company registration: look up official registration facts like incorporation date and status via OpenCorporates (
company_registration).All tools support configurable timeframes, geos, limits, and concise vs full response formats, so you can use them for quick checks or deep studies.
Allows querying Google Trends data, including search interest over time, related queries and topics, regional interest breakdowns, and trending searches for market research.
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., "@Google Trends MCP Compare search interest in 'lab grown diamonds' vs 'diamond jewellery' in India over 12 months."
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.
gutcheck
Check your gut against the internet before you commit.
gutcheck is a market researcher for Claude Code. Give it an idea you want to build, a problem you keep hitting, a topic you're curious about, or a decision you're stuck on. It works out what would actually answer the question, designs a study to match, pulls live evidence from Google Trends, Reddit, Google News, Wikipedia, Hacker News, GitHub, the App Store, YouTube and the web, then tells you what it thinks and why.
It scales with the stakes. A hunch gets ten minutes and a straight answer. A case competition, business plan, market landscape, or dissertation gets a research plan first, run in phases, in the shape that audience expects.
/gutcheck is there demand for a simpler meal-planning app for busy parents?
/gutcheck freelancers keep getting paid late, how common is this and what actually works?
/gutcheck is pickleball still growing or has it peaked?
/gutcheck should I learn Rust or Go in 2026?Free and open source. Works with no API keys. Everything runs on your machine.
Install (30 seconds)
Open Claude Code and paste this. Claude does the rest.
Install gutcheck: run
git clone --single-branch --depth 1 https://github.com/jain-eshan/gutcheck.git ~/.claude/skills/gutcheck && ~/.claude/skills/gutcheck/setup, then tell me to restart Claude Code and run/gutcheck setup.
Or run it yourself in a terminal:
git clone --single-branch --depth 1 https://github.com/jain-eshan/gutcheck.git ~/.claude/skills/gutcheck && ~/.claude/skills/gutcheck/setupThe setup script installs uv if you don't have it, installs the Python dependencies, registers the data tools with Claude Code, and creates a private settings file at ~/.config/gutcheck/.env. Restart Claude Code once afterwards.
Requirements: macOS or Linux, Claude Code, and git. Windows hasn't been tested yet; WSL is the likely route.
Related MCP server: Google Trends MCP Server
Other apps: Claude chat, ChatGPT
Claude Code gets everything. Other apps can't run the local data tools, so gutcheck falls back to web-only mode: same study design and report, but the evidence comes from the app's own web search, and the report says so and caps its confidence. No Trends numbers, no Reddit upvotes.
Run python3 scripts/bundle.py to build dist/:
App | Use |
claude.ai / Claude desktop | Upload |
ChatGPT | Create a Custom GPT. Paste |
Any other chat | Paste |
For the full data outside Claude Code, run uv run server.py serve 8000 and host it somewhere public. It speaks streamable HTTP MCP at /mcp, so it can be added as a remote connector. Untested when hosted: Google Trends and Reddit tend to block cloud IP addresses, so those two may fail there.
Setup: /gutcheck setup
Run this once after installing. It's a conversation, not a config file hunt:
It asks what's actually on your mind first, and checks every data source in the background while you answer.
It asks the little it can't infer (which country, what you do), so later runs know whether to check India or the US and which communities to search.
It offers an optional key only when one would help your question, described by what it gets you rather than by its name, and saves it for you.
It finishes by researching the thing you named, for real, so setup ends with an answer instead of instructions.
You can skip the keys. Seven sources work with zero setup, and step 4 works immediately, even before you restart Claude Code.
What you get
A point of view, not a pile of search results. Every run leads with what gutcheck thinks is true, backs it with the evidence, argues the other side, and ends with something you can do this week. Here's a real one:
GUTCHECK REPORT
════════════════════════════════════════════════════
Question: freelancers keep getting paid late by clients - how common is this and what actually works?
Type: PROBLEM
Checking: Late payment is a widespread freelancer problem with no settled fix.
Verdict: MODERATE_SIGNAL
Confidence: MEDIUM (6 sources, 5-year window, worldwide)
THE READ
It's not you, and it's not rare: across the surveys, most freelancers get paid
late at least sometimes, and roughly a third of all invoices land after the due
date. But the second half of your question has an uncomfortable answer. The fixes
are known and boring, and they work: a deposit up front, a late fee written into
the contract, an invoice sent the day the work ends, and automatic reminders after.
Almost nobody is short of tools here, because every invoicing app already sends
reminders. What people are short of is the nerve to enforce terms with a client
they're afraid of losing. The threads aren't asking how to chase an invoice; they're
asking whether they're allowed to. That's a confidence problem wearing a process
problem's clothes, and it's why the pain persists even though the playbook is settled.
WHAT'S GOING ON
- What you're up against today is a polite reminder email and hoping. That's the
status quo, and it mostly works slowly: most late invoices arrive within two
weeks, so this reads as a cash-flow and dignity problem, not a bad-debt one.
- Desire, not demand. Search interest for the problem is climbing, but searches
for tools that solve it sit near zero. People are looking for reassurance and
scripts, not software.
- The sources disagree in a useful way: news coverage is about freelancer finance
in general, while the actual complaints are about specific relationships with
bigger clients. The power imbalance is the real subject.
- The sharpest thing anyone said: "these bigger companies are acting like Net 30
means Net 60." Nobody in those threads is confused about what to do. They're
weighing whether enforcing it costs them the account.
THE CASE AGAINST
The strongest counter is that this was checked worldwide and in English, and late
payment is heavily shaped by local law: the EU and UK have statutory interest rules
that change what "what works" even means. A second is that the survey numbers all
come from companies selling invoicing or payroll products, which have an interest in
the problem looking big. Checking one country properly, with its own rules, would
sharpen this a lot.
What would change this:
- Evidence that deposits and late fees get refused in practice would move this to
STRONG_SIGNAL for "no settled fix", since the known playbook would then not work.
- A survey showing most late invoices go unpaid entirely, rather than arriving late,
would change this from a cash-flow problem to a much more serious one.
Next steps:
- Put a 50% deposit and a late-fee line in your next two contracts and see whether
either client actually pushes back. Most don't, and that's the fastest way to learn it.
- Check whether your current invoicing tool already sends automatic reminders before
you pay for anything new. It probably does.
- Ask in r/freelance what finally got someone's worst payer to pay on time, and count
how many answers are about process versus about firing the client.
Caveats:
- "late payment" on Google Trends also covers loans and credit cards, so part of that
rise has nothing to do with freelancing.
- All survey figures come from vendors selling invoicing or payroll tools.
- Reddit without an API key returns posts without upvote counts, so popularity is unknown.
- Wikipedia had no usable article here (under 25 views a month), so it was dropped.
── Evidence ──
Google Trends, 5 years, worldwide: "late payment" rose from ~26 (2021) to a 55-86
range through 2026. "unpaid invoice" and "invoice reminder" stayed at 1-5 throughout.
Reddit, r/smallbusiness + r/graphic_design, 2026: "Do you guys actually enforce late
fees on Net 30 invoices or is it an empty threat?", "I'm constantly chasing money
I've already earned."
App Store, US: Invoice Simple (122k ratings), Invoice Fly (105k), Invoice2go (56k),
all updated within the month. Standalone late-payment chasers: 0 ratings.
[surveys, news and advice blocks trimmed for this README]
Sources used: interest_over_time, related_queries, reddit_signal, news_coverage, app_store_apps, wikipedia_pageviews, web search
════════════════════════════════════════════════════
Bottom line: "Most freelancers get paid late, the fixes are known and boring (deposit,
late fee, instant invoice, auto-reminders), and the real blocker is enforcing terms
with clients you're afraid to lose."The raw numbers sit at the bottom on purpose, so you can check the work without
wading through it first. After the report, gutcheck asks you something specific
about what it found. Say "save this" and it writes the report to ~/gutcheck-reports/.
How it works
It designs the study before running it. It works out what decision you're making, what would change your mind, and who the output is for, then picks from nine study types and writes a short plan: the research questions, what evidence would answer each, what's out of scope, and what only you can find out (nobody's public data can replace ten customer conversations, and it will say so).
Study | What you get |
Quick check | The default. One claim, ten minutes, a straight answer. |
Opportunity validation | Demand, incumbents, the narrow group with the problem worst, what would kill it |
Case competition | Industry structure, players, what's changing, customer evidence, recommendation, and the rebuttals a jury will throw |
Business plan / investment memo | Bottom-up market size with the arithmetic shown, competition, go-to-market, ranked assumptions |
Market landscape | Players grouped by approach, pricing picture, underserved segments |
Problem diagnosis | How common, in whose words, what actually works |
Decision analysis | The axis that really decides it, options compared on one scale |
Deep study | Research questions, method, findings, limitations, references |
Trend watch | Five-year shape, what's rising underneath, fad or trend, what to watch |
For a small question it skips the ceremony entirely and just answers. For a big one it shows the plan, asks what to cut, then runs it in phases and tells you what changed after each.
How it thinks
It forms a view. The analysis comes from crossing sources, which no single tool can do: flat search plus a crowded App Store means a settled market; loud Reddit plus flat search means an intense problem for a small group; busy builders plus silent users means a solution chasing a problem.
Desire versus demand. Saying you want something is not downloading, paying, or switching. gutcheck says which one the evidence actually shows.
It names the status quo. Every idea competes with a spreadsheet, an incumbent, or people deciding to live with it. "Nothing" is the hardest competitor there is.
Four kinds of question. An idea (is there room), a problem (is it just me, what works), a topic (growing or fading), a decision (which one, and on what axis). Each gathers different evidence.
One claim, one verdict. Your question becomes a single testable sentence, rated
STRONG_SIGNAL,MODERATE_SIGNAL,WEAK_SIGNAL,MIXED_SIGNALorINSUFFICIENT_DATA. "Not enough data" is an allowed answer, and it will say what would settle it.It argues against itself. Every report includes the strongest case that its own read is wrong.
Receipts, never invented numbers. Every figure traces to a tool result or a cited page.
It remembers. What you check is saved locally, so a similar question later opens with what you found last time and what moved.
--deeppulls in more sources (regional breakdowns, GitHub, App Store, YouTube, Product Hunt launches, review sites) when the decision is expensive.
Sources
Source | What it tells you | Key needed? |
Google Trends | Is search interest rising or falling, what related searches are breaking out, where | No |
What people actually say, ask, and complain about, in their own words | No (1 search a minute). Optional key removes the limit | |
Google News | Is the press covering it, and what angle it takes | No |
Wikipedia pageviews | Reading interest, a check on search hype | No |
Hacker News + GitHub | Are builders shipping in this space | No. Optional token raises GitHub's limit |
App Store | Who already serves this need, and how many people rate them | No |
Google Play | Android competitors, and what their users complain about in reviews (asks first) | No |
Web search | Competitors, surveys, forum threads, Product Hunt launches | No (built into Claude Code) |
YouTube | How much people watch content about it | Free key, about 3 minutes |
OpenCorporates | Is a named company officially registered, and since when | Free account |
Using the data tools outside Claude Code
The /gutcheck playbook is a Claude Code skill, but the data tools are a standard MCP server that any MCP client can use (Cursor, Codex, Claude Desktop, and others). After cloning and running setup, add this to your client's MCP config:
{
"mcpServers": {
"gutcheck": {
"command": "/Users/YOU/.local/bin/uv",
"args": ["run", "--directory", "/Users/YOU/.claude/skills/gutcheck", "server.py"]
}
}
}Use the full path to uv (run which uv to find it), since desktop apps often can't see your terminal's PATH. You'll get the 11 tools. Ask your assistant to use them, or point it at SKILL.md for the full method.
Update and uninstall
gutcheck checks GitHub at most once a day when you run it. If there's something new it says so in one line and offers to update after answering your question, rather than interrupting it:
(gutcheck is 3 commits behind: "sharper verdicts on thin B2B evidence". Want me to update after this?)Say yes and it runs the pull for you, then tells you what changed. Or update whenever you like with /gutcheck upgrade. If your copy has local edits, it won't touch them; it tells you instead.
Uninstall:
claude mcp remove gutcheck --scope user && rm -rf ~/.claude/skills/gutcheck ~/.config/gutcheckPrivacy
gutcheck has no server, account, or analytics. Your questions go only to the sources listed above, straight from your machine. API keys stay in ~/.config/gutcheck/.env (readable only by you). Your history stays in ~/.config/gutcheck/history.jsonl.
Known limits
Google Trends has no official API. gutcheck uses pytrends, which reads the public site. If you run many checks back to back, Google may block you for a few minutes. The report marks that source as unavailable and carries on.
Keyless Reddit allows one search a minute. gutcheck waits it out, so a report can take about a minute. A Reddit API key removes the limit, but Reddit reviews new API apps by hand, which can take days.
Trends numbers are relative (0-100), not search counts. The report treats them that way.
OpenCorporates covers registration facts only, never funding or revenue. No free source for that exists.
How it's built
SKILL.md router, voice, and what to do before researching
design.md scope the job, pick the study, write the plan
research.md run it: gather, form a view, write the report
setup.md the /gutcheck setup conversation
references/
study-types.md nine study archetypes, their questions and output shapes
research-craft.md desire vs demand, the status quo, triangulation, source tilt
reading-signals.md what each source's numbers mean, and the traps
playbooks.md how to aim an idea, problem, topic, or decision question
server.py MCP server: 11 tools that fetch raw data, no interpretation
setup installer (uv, dependencies, MCP registration, settings file)
tests/ contract tests (mocked or recorded, no network)
tests/eval/ report-structure checks plus evals that run through `claude -p`The tools also run from a terminal, which is how setup can research something in the session you installed it in:
cd ~/.claude/skills/gutcheck && uv run server.py call reddit_signal '{"query":"meal prep app"}'
cd ~/.claude/skills/gutcheck && uv run server.py doctor # health-check every sourceThe split is deliberate. The server only fetches data. Every judgment lives in the
markdown, in plain English, so you can read exactly how a verdict gets decided and
change it. If you think a verdict was wrong, the fix is usually one paragraph in
references/research-craft.md.
Run the tests:
uv sync --group dev && uv run pytestContributing
Issues and PRs are welcome, especially new keyless data sources, sharper interpretation rules in the markdown, and reports where gutcheck got the verdict wrong (paste the report and say why).
Working on gutcheck itself
Keep two copies. The one in ~/.claude/skills/gutcheck is what Claude Code runs; leave it alone and let it update itself. Work somewhere else:
git clone https://github.com/jain-eshan/gutcheck.git ~/dev/gutcheck
cd ~/dev/gutcheck && uv sync --group devEdit there, run uv run pytest, push, then let the installed copy pick it up the next time you run /gutcheck (or force it with /gutcheck upgrade). Editing the installed copy directly works but blocks updates, since a pull would overwrite your changes — the update check notices and refuses rather than clobbering.
Most changes are markdown, not Python. The judgment lives in SKILL.md (voice, routing), design.md (how a study gets planned), research.md (how a report gets written), and references/ (what it knows about reading evidence). A verdict that felt wrong is usually a paragraph in references/research-craft.md, not a code change.
To try a change before pushing, point Claude Code at your dev copy for one session:
claude mcp add --scope local gutcheck-dev -- uv run --directory ~/dev/gutcheck server.pygutcheck started as market-signal-mcp, a Google Trends wrapper for startup-idea checks. The install flow borrows from Garry Tan's gstack.
License
MIT. See LICENSE.
Available Tools
11 toolsapp_store_appsA
Existing iPhone/iPad apps matching a query, from Apple's public iTunes Search API - who already serves this need, and how many people rate them (rating count is a rough proxy for user base). No setup needed.
Args: query: search terms, e.g. "meal planner" or "invoice". country: ISO country code for the store, e.g. "US" (default), "IN", "GB". limit: max apps, capped at 50.
Returns: A list in App Store relevance order, each with "name", "developer", "rating", "rating_count", "price", "genre", "released", "last_updated", "url".
Inputs: query (required), limit, country.
builder_activityA
Are people actually building and shipping in this space? Hacker News stories
(launches, Show HNs, debates) plus GitHub repositories - a builder signal, as opposed
to search interest or community chatter. Works with no setup; a GITHUB_TOKEN saved via
/gutcheck setup raises GitHub's limit from 10 to 30 searches a minute.
For Product Hunt launches, use web search restricted to producthunt.com instead - Product Hunt's API has no search endpoint.
Args: query: search terms, e.g. a product category ("habit tracker") or problem.
Returns: {"hn": {"total": int, "stories": [...]}, "github": {"total": int, "repos": [...]}}. Each story: title, points, num_comments, url, created_at. Each repo (top 10 by stars): name, description, stars, last_push, url.
Inputs: query (required).
company_registrationA
Company registration lookup via OpenCorporates - registration facts only (incorporation date, status, company number). Does NOT cover funding, valuation, or traction data - no free API exists for that (see README for why).
Requires a free OpenCorporates API token: as of 2026 OpenCorporates requires a
token on every request, even on the free tier (roughly 50 requests/day, 200/month).
Register at https://opencorporates.com/api_accounts/new and save it as
OPENCORPORATES_API_TOKEN via /gutcheck setup.
Args: name: company name to search for. jurisdiction: optional OpenCorporates jurisdiction code (e.g. "in", "us_de") to narrow results.
Returns: A list of up to 5 matches, each containing "company_name", "jurisdiction_code", "incorporation_date", "company_number", "current_status", "opencorporates_url". Empty list if no matches. A setup-instructions string if OPENCORPORATES_API_TOKEN is unset, or OpenCorporates' own rejection message if the token is invalid/expired.
Inputs: name (required), jurisdiction.
interest_by_regionA
Search interest for a keyword broken down by state/region within a country, or by country when geo is "" (worldwide).
Args: keyword: a single search term. timeframe: pytrends timeframe string, e.g. "today 12-m". geo: ISO country code (e.g. "US", "IN"), or "" for worldwide (default). response_format: "concise" (default) returns only the top 10 regions by interest, rounded to whole numbers. "full" returns every region, unrounded.
Returns: A list of records, one per state/region within the specified geo, each containing: - "geoName": the state/region name (e.g. "California"), or the country name when worldwide - A column with the keyword name as the key: relative search interest (0-100 scale) for that region. Higher values indicate higher relative interest in that region compared to others in the same country. This is Google Trends' standard region-relative scale.
Inputs: keyword (required), geo, timeframe, response_format.
interest_over_timeA
Relative Google search interest (0-100) over time for up to 5 keywords, compared side by side.
Args: keywords: 1-5 search terms to compare. Only the first 5 are used; additional keywords are silently dropped. timeframe: pytrends timeframe string, e.g. "today 12-m", "today 5-y", "now 7-d", or "YYYY-MM-DD YYYY-MM-DD". geo: ISO country code (e.g. "US", "IN", "GB"), or "" for worldwide (default). response_format: "concise" (default) covers the whole requested timeframe, thinned to about 26 evenly spaced points (first and last always kept) and rounded to whole numbers, so the shape of the window is intact at a low token cost. "full" returns every point unrounded - use it when you need week-by-week detail.
Returns: A list of records, one per date, each containing: - "date": ISO date string - "isPartial": present and true only when the period is incomplete (most recent point) - omitted when false in "concise" mode, since false is the common case. - One numeric key per keyword (0-100 relative interest value)
Inputs: keywords (required), geo, timeframe, response_format.
news_coverageA
Recent news coverage from Google News - is the press writing about this, and what angle are they taking? Useful for spotting funding rounds, regulation, launches, and whether a topic is getting more or less attention. No setup needed.
Args:
query: search terms.
geo: ISO country code for the news edition, e.g. "US" (default), "IN", "GB".
recent: how far back - "7d", "1m", "1y" (default). Uses Google News' own when: filter.
limit: max headlines to return (Google returns up to ~100; "total" counts all of them).
Returns: {"total": int, "last_30_days": int, "headlines": [{"title", "source", "published", "url"}]}, newest first. "total" and "last_30_days" are counts within Google's capped result set, so treat them as a rough attention gauge, not an exact article count.
Inputs: query (required), geo, limit, recent.
reddit_signalA
What real people on Reddit are saying, asking, or complaining about - qualitative community signal, as opposed to Trends/Wikipedia's passive search/reading numbers.
Works with no setup via Reddit's public search feed (which returns post text but not
scores, and rate-limits after a burst of requests). If REDDIT_CLIENT_ID and
REDDIT_CLIENT_SECRET are saved via /gutcheck setup, uses the official API instead,
which adds score and comment counts.
Args: query: search terms. subreddits: optional subreddit names to restrict the search to (e.g. ["startups", "SaaS"]). limit: max results, capped at 100. time_filter: "week", "month", "year" (default), or "all".
Keep the query short (2-4 words) and pass subreddits when obvious communities exist.
Reddit's keyless search matches loosely on long questions, so results that share no
meaningful word with the query are dropped and the rest are ranked by how many query
words they match.
Returns: A list of records with "title", "subreddit", "snippet" (first ~300 chars of the post body), "url", "created". "score" and "num_comments" are included only in API mode.
Inputs: query (required), limit, subreddits, time_filter.
wikipedia_pageviewsA
Monthly Wikipedia pageview counts for an article - a free, no-auth reference/reading interest signal that complements Google Trends' search-interest signal. The two diverging (e.g. a term trending in search but flat on Wikipedia) can itself be a signal worth flagging.
Args: article: an English Wikipedia article title, e.g. "Artificial_intelligence" or "Machine learning" (spaces are handled automatically). timeframe: how far back to request, as a simple duration - "P1Y" (1 year, default), "P6M" (6 months), "P90D" (90 days). Only whole Y/M/D forms are supported. response_format: "concise" (default) returns only the most recent 12 months. "full" returns the entire requested timeframe.
Returns: A list of records, one per month, each containing: - "month": "YYYY-MM" - "views": total pageviews that month (all access methods, human traffic only - bot traffic is excluded by Wikimedia's "user" agent filter)
Inputs: article (required), timeframe, response_format.
youtube_videosA
YouTube videos matching a query, with view and comment counts - shows how much people watch content about a topic (tutorials, reviews, "I tried X" videos), which is often a stronger consumer-interest signal than search volume.
Requires a free YOUTUBE_API_KEY (Google Cloud, YouTube Data API v3), saved via
/gutcheck setup. Each call uses about 101 of the free 10,000 daily quota units.
Args: query: search terms. limit: max videos, capped at 25. published_after_days: only videos from the last N days; omit for any time.
Returns: A list in YouTube relevance order, each with "title", "channel", "published", "views", "likes", "comments", "url". A setup-instructions string if no key is saved.
Inputs: query (required), limit, published_after_days. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 11 tools
Each tool targets a distinct data source or dimension: Google Trends topics, queries, time series, regional breakdown, plus Wikipedia, OpenCorporates, Reddit, HN/GitHub, Google News, App Store, and YouTube. Even within Trends, related_topics vs related_queries are clearly separated by content type. No ambiguity.
All tool names follow a consistent snake_case noun phrase pattern (e.g., interest_over_time, reddit_signal, builder_activity). No mixing of conventions or verb styles, making the set predictable and easy to navigate.
With 11 tools covering a wide but focused range of market research signals, the count is well-scoped. Each tool contributes a unique data source, and none feel redundant or missing for the server's stated purpose.
The surface covers search interest, related topics/queries, regional data, reference interest (Wikipedia), community chatter (Reddit), builder activity (HN/GitHub), news coverage, app ecosystem, and YouTube viewership. Minor gaps exist (e.g., no global 'trending now' without a keyword, no multi-keyword regional comparison), but core workflows are well supported.
Maintenance
Related MCP Connectors
Google Trends: Search, Images, News, Shopping over time, growth metrics. Free key at trendsmcp.ai
Google Trends for agents: interest over time, by region, rising queries, Trending Now. No API key.
Google Trends realtime & entities
Bulk Google Trends: interest over time, regions, rising queries and plain-English trend summaries.
Related MCP Servers
- AlicenseBqualityDmaintenanceProvides access to Google Trends data including status, trending questions, and trending topics via MCP tools.2335 npm36MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to access Google Trends data for comparing keywords, discovering trending searches, and analyzing regional interest through natural language.2MIT
- AlicenseAqualityDmaintenanceProvides free Google Trends data (interest over time, term comparison, related queries, trending now, regional breakdown) to MCP-compatible AI clients without needing an API key.5134 npm2MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to query Google Trends data, including search interest over time, regional breakdowns, trending searches, and keyword ideas.MIT