Yes, related queries move, but not in the way the question suggests. The list is a snapshot tied to a time window and a fetch time, not a fixed property of a keyword. Repeat calls minutes apart on 2026-11-19 returned identical results in six of seven tests: Keyword Planner ideas for "air fryer" matched 30 out of 30, the News context for "microsoft outage" matched 10 out of 10, and the Google Trends board matched 25 out of 25. The daily series and the Reddit context matched too. The YouTube context for "air fryer" did not match. It kept 8 of 10 titles and replaced 2, with 2 more swapping places. The time window moved the answer further than any repeat did. "air fryer" on Google Search rose 5.88% over 7 days (51 to 54) and fell 8.47% over 12 months (59 to 54). A developer should store each list with its window and fetch time, cache it, and treat it as a suggestion list that expires.
There is no related queries call in the Trends API
A raw call with mode get_related_queries for "air fryer" on Google Search returned an error on 2026-11-19. The call looks like this:
import json
import os
import requests
api_key = os.environ.get("TMCP_API_KEY") or os.environ.get("TRENDS_API_KEY")
if not api_key:
raise SystemExit("Set TMCP_API_KEY first.")
resp = requests.post(
"https://api.trendsmcp.ai/api",
json={"mode": "get_related_queries", "keyword": "air fryer", "source": "Google Search"},
headers={"Authorization": "Bearer " + api_key},
timeout=60,
)
payload = resp.json()
body = json.loads(payload["body"]) if isinstance(payload.get("body"), str) else payload
print(body["error"], "-", body["message"])
# invalid_mode - 'get_related_queries' is not a valid mode.
The error lists five valid modes: get_context, get_growth, get_reviews, get_time_series and get_top_trends. This run found no mode that returns Google Trends related queries. The API exposes time series, growth, context, reviews and boards, but the mode tested here is not valid. That gap shapes the whole answer. A developer who wants related queries can use Google Trends directly, use a scraper library built on it, or build a proxy from related keyword data and context data. Each route has a different stability profile, and the tests below measure two of them. The Keyword Planner route returns related keywords with monthly volumes. The context route returns the posts and videos people engage with around a keyword. Neither route is Google Trends related queries, and the piece says so plainly instead of pretending one of them is.
Repeat calls minutes apart matched, except one list
Seven repeat tests ran on 2026-11-19, each call repeated minutes after the first with identical parameters. Six returned identical results. One did not.
| Test | Run 1 | Run 2 | Match |
|---|---|---|---|
| Keyword Planner ideas, "air fryer", limit 30 | 30 keywords | 30 keywords | 30 of 30, same order, same volumes |
| Keyword Planner ideas, "bitcoin", limit 30 | 0 keywords | 0 keywords | empty on all three calls made |
| News context, "microsoft outage", limit 10 | 10 items | 10 items | 10 of 10, same order, same raw response |
| Google Trends board, limit 25 | 25 rows | 25 rows | 25 of 25, same snapshot time |
| Daily series, "air fryer", Google Search, 92 points | 92 points | 92 points | 92 of 92, identical values |
| Reddit context, "air fryer", limit 10 | 0 items | 0 items | 0 items, same error on both runs |
| YouTube context, "air fryer", limit 10 | 10 videos | 10 videos | 8 of 10 titles, 2 replaced |
The bitcoin seed was called a third time; all three calls came back empty. The Planner list is a monthly bucket, which suggests stability is expected there. Its top three held firm: "air fryer" at 4,090,000 monthly searches, "airfryer" at 2,240,000 and "ninja air fryer" at 1,000,000. The board carried the same snapshot timestamp on both calls, 2026-11-19T09:01:33Z, which fits the match. Its top five were "sean duffy", "microsoft outage", "gta 6", "robert pattinson" and "cyberattack". The daily time series for "air fryer" also matched exactly across two calls: 92 points from 2026-08-19 to 2026-11-18, ending at index 56 with volume 4,181,531. The YouTube context broke the pattern. Run 1 included "Air Fried Blooming Onion - You Suck at Cooking (episode 183)" and "I TESTED VIRAL AIR FRYER RECIPES 🔥 ARE THEY WORTH THE HYPE? 👀 | TESTED BY SHIVESH". Run 2 replaced them with "Air Fryer vs. Microwave: What Should You Really Use?" and "Onion Pakoda in Air Fryer". Two more videos swapped positions 2 and 3. The top video stayed put in both runs, "You're Using Your Air Fryer WRONG!" with 153,263 views. The lesson is narrow. Six of the seven tests repeated exactly, and the one that changed, YouTube, is the list fetched at call time rather than served from a stamped snapshot. That pattern fits a cached-versus-live split, but one changed list does not prove it.
Top queries answer a different question than rising queries
Google Trends splits related queries into two lists, and each list has its own kind of movement. Google's help page states that Top searches are the terms most frequently searched with the entered term in the same search session, within the chosen category, country or region. Rising searches are the terms with the most significant growth in volume in the requested time period, and a term marked Breakout grew by more than 5,000%. The Top list tracks habit. The Rising list tracks velocity. Google's definitions point to slower movement for Top and faster movement for Rising, but this run measured neither list over time, so the refresh cycles below are a working guess, not a measured rate. That split is one plausible source of the instability developers report. A list that looks broken can be a Rising list doing its job after the growth behind it faded. Any code that stores related queries should store which list each entry came from, because the two lists need different refresh cycles and different trust.
The time window moves the answer more than the repeat does
Growth calls for the same keyword on Google Search, run on 2026-11-19, gave different signs depending on the window. The figures below come from point to point growth on weekly index values.
| Keyword | 7 days | 30 days | 12 months |
|---|---|---|---|
| air fryer | +5.88% (51 to 54) | +3.85% (52 to 54) | -8.47% (59 to 54) |
| bitcoin | -4.17% (24 to 23) | -4.17% (24 to 23) | -54.90% (51 to 23) |
"air fryer" rose over 7 and 30 days and fell over 12 months, so a related query list built on the short window points at different neighbours than one built on the long window. "bitcoin" fell 4.17% over 7 days (24 to 23) and 54.90% over 12 months (51 to 23), a gap that changes which queries count as rising. Growth recent dates are weekly points, so they land on different dates per keyword: 2026-11-14 for "air fryer" and 2026-11-07 for "bitcoin", while the daily series for "air fryer" runs to 2026-11-18. A related query list without a stated window is not comparable with another list for the same keyword. The window is part of the data, not metadata to skip. The daily series shows the same point in finer detail. "air fryer" ranged from index 48 to 75 across the 30 days to 2026-11-18, with a 30 day average of 57.27, so even a stable keyword wobbles day to day.
Build for a snapshot, not for a fixed list
The working pattern is to fetch, stamp, store and compare. Each snapshot records the keyword, the source, the window and the fetch time, then the code compares sets of queries across snapshots instead of assuming any single fetch is canonical. A cache of a few hours is a reasonable starting point for Top queries, and a shorter cycle fits Rising queries while a topic is hot. The guide to caching Trends API responses covers TTL shapes that fit this pattern. The snippet below fetches a YouTube context list and stores it as a stamped snapshot. The parse step sits in the code because body arrives as a JSON encoded string that needs a second parse, not as a ready object.
import json
import os
from datetime import datetime, timezone
import requests
api_key = os.environ.get("TMCP_API_KEY") or os.environ.get("TRENDS_API_KEY")
if not api_key:
raise SystemExit("Set TMCP_API_KEY first.")
resp = requests.post(
"https://api.trendsmcp.ai/api",
json={"mode": "get_context", "keyword": "air fryer", "source": "YouTube"},
headers={"Authorization": "Bearer " + api_key,
"Content-Type": "application/json"},
timeout=60,
)
payload = resp.json()
raw_body = payload.get("body", payload)
data = json.loads(raw_body) if isinstance(raw_body, str) else raw_body
if isinstance(data, dict) and data.get("error"):
raise SystemExit("API error: " + str(data["error"]))
source = (data.get("sources") or [{}])[0]
source_error = source.get("error")
snapshot = {
"keyword": data.get("keyword", "air fryer"),
"source": "YouTube",
"window_days": data.get("window_days"),
"fetched_at": datetime.now(timezone.utc).isoformat(),
"source_error": source_error,
"titles": [item.get("title") for item in source.get("items", [])],
}
The snippet ran in this run against the live API and returned a snapshot with window_days 7, 10 titles, and fetched_at 2026-11-19T10:25:30Z. A source that fails, like the Reddit call below, lands in source_error with an empty title list instead of crashing the code. Downstream code should read snapshot["titles"] as a set, never as an ordered list with fixed positions. Positions moved between the two test runs, and the guide to parsing Trends API JSON shows the same defensive shape for the rest of the response. Alerting belongs on set overlap, not on a single missing title. A drop below 8 of 10 shared titles between consecutive snapshots is a reasonable trigger to re-fetch and log, based on the 8 of 10 overlap measured here. For boards, the realtime API guide explains which feeds update on a snapshot clock and which fetch at call time, so the refresh cycle can match the feed. When the snapshot feeds a chart or a model, normalizing the series first keeps the 0 to 100 index comparable across windows.
Three ways the call can come back empty
Empty results are part of the behaviour, not an exception to hide. Three distinct cases showed up in this run, and each needs different handling.
First, Keyword Planner ideas for "bitcoin" returned an empty list on three separate calls with limit 30. The API gave no reason. Code should treat an empty ideas list as "no data for this seed" and fall back to a different seed or source, not retry the same call in a loop.
Second, the Reddit context for "air fryer" returned 0 items on both runs with error source unavailable. The call succeeded, the source did not. Code should log the source error, serve the last good snapshot for that source, and keep the other sources running.
Third, a board snapshot can look fresh while it is not. Both Google Trends board calls carried the same as_of_ts, 2026-11-19T09:01:33Z, minutes apart. Code should read that timestamp and refuse to present the board as live when the snapshot is older than the refresh cycle. A stale snapshot is fine for a daily digest and wrong for an alert.
Pick the keywords that drive decisions, run the same repeat test on them with the windows the product actually uses, and keep every snapshot. The list will still move. The difference is that the movement will be measured, not guessed.