Using Google Trends Unofficial API with Python (2026)

Using Google Trends Unofficial API with Python (2026)

Google Trends doesn't have an official API, but there's an undocumented one that powers the web UI at trends.google.com. It's stable, returns clean JSON, and doesn't require authentication. Here's how to use it directly with Python — no pytrends library needed (it's outdated and breaks constantly).

How the API Works

When you search on Google Trends, the browser makes two requests:

1. Explore request — sends your search terms and gets back widget tokens
2. Widget data request — uses those tokens to fetch the actual data (timelines, related queries, etc.)

The flow: /trends/api/explore → extract tokens → /trends/api/widgetdata/multiline or /trends/api/widgetdata/relatedsearches.

Every response is prefixed with )]}', (5 characters of XSSI protection). Strip that before parsing. This is Google's standard anti-JSON-hijacking measure — you'll see it on most Google internal APIs.

Why Not Use pytrends?

pytrends is the commonly cited Python library for this. The problems: - Not maintained — the last significant update was 2022 - Breaks whenever Google updates their token or widget structure - Doesn't expose all the API endpoints (missing geographic resolution data) - Limited error handling — silently returns empty data on rate limits - Can't handle concurrent requests safely

Building directly against the raw HTTP API takes 30 more minutes but gives you full control, faster performance, and no dependency on unmaintained code.

Authentication and Rate Limits

The Google Trends API is unauthenticated. You don't need an API key. Google doesn't rate-limit individual requests aggressively — a 1-second delay between requests is sufficient for normal use.

That said, if you're making hundreds of requests per hour from a single IP, Google will start returning 429s or empty responses. For production use, route requests through a proxy pool. ThorData's residential proxies work well here since each IP looks like a different user making occasional searches.

Complete Client Implementation

import httpx
import json
import time
import random
from typing import Optional

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                  "AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
    "Accept": "application/json, text/plain, */*",
    "Accept-Language": "en-US,en;q=0.9",
    "Referer": "https://trends.google.com/trends/",
}

BASE_URL = "https://trends.google.com"

class GoogleTrendsClient:
    """Client for the unofficial Google Trends API."""

    def __init__(self, hl: str = "en-US", tz: int = -60, proxy: Optional[str] = None):
        """
        Args:
            hl: Language code (en-US, de, fr, etc.)
            tz: Timezone offset in minutes (UTC-60 = UTC+1)
            proxy: Optional proxy URL (e.g. "http://user:[email protected]:9000")
        """
        self.hl = hl
        self.tz = tz
        self.base_params = {"hl": hl, "tz": tz}
        proxies = {"https://": proxy} if proxy else None
        self.client = httpx.Client(
            headers=HEADERS,
            proxies=proxies,
            timeout=20,
            follow_redirects=True,
        )

    def _parse_response(self, resp: httpx.Response) -> dict:
        """Strip XSSI prefix and parse JSON."""
        if resp.status_code == 429:
            raise Exception("Rate limited by Google Trends. Wait or rotate proxy.")
        resp.raise_for_status()
        text = resp.text
        if text.startswith(")]}',"):
            text = text[5:]
        return json.loads(text)

    def get_widgets(
        self,
        keywords: list[str],
        geo: str = "",
        time_range: str = "today 12-m",
        category: int = 0,
        gprop: str = "",
    ) -> list[dict]:
        """
        Fetch widget tokens for keywords.

        Args:
            keywords: Search terms to compare (max 5)
            geo: ISO country code ("US", "GB") or region ("US-CA"). Empty = worldwide.
            time_range: Time range string. See time parameter reference below.
            category: Category code (0 = all). See category reference.
            gprop: Google property ("", "images", "news", "froogle", "youtube")

        Returns:
            List of widget dicts with tokens and request payloads.
        """
        if len(keywords) > 5:
            raise ValueError("Google Trends supports max 5 keywords per comparison")

        comparison_items = [
            {"keyword": kw, "geo": geo, "time": time_range}
            for kw in keywords
        ]
        req = {
            "comparisonItem": comparison_items,
            "category": category,
            "property": gprop,
        }

        params = {**self.base_params, "req": json.dumps(req)}
        resp = self.client.get(f"{BASE_URL}/trends/api/explore", params=params)
        data = self._parse_response(resp)
        return data.get("widgets", [])

    def interest_over_time(self, widgets: list[dict]) -> list[dict]:
        """Extract time series data (0-100 scale)."""
        widget = next((w for w in widgets if w["id"] == "TIMESERIES"), None)
        if not widget:
            return []

        params = {
            **self.base_params,
            "req": json.dumps(widget["request"]),
            "token": widget["token"],
        }
        resp = self.client.get(
            f"{BASE_URL}/trends/api/widgetdata/multiline",
            params=params,
        )
        data = self._parse_response(resp)

        points = []
        for point in data.get("default", {}).get("timelineData", []):
            points.append({
                "date": point["formattedTime"],
                "timestamp": point.get("time"),
                "values": point["value"],
                "formatted": point.get("formattedValue", []),
                "has_data": point.get("hasData", [True]),
            })
        return points

    def interest_by_region(
        self, widgets: list[dict], resolution: str = "COUNTRY"
    ) -> list[dict]:
        """
        Get geographic breakdown of search interest.

        Args:
            resolution: "COUNTRY", "REGION", "CITY", or "DMA" (US metros)
        """
        widget = next((w for w in widgets if w["id"] == "GEO_MAP"), None)
        if not widget:
            return []

        # Modify request to set resolution
        req = dict(widget["request"])
        req["resolution"] = resolution

        params = {
            **self.base_params,
            "req": json.dumps(req),
            "token": widget["token"],
        }
        resp = self.client.get(
            f"{BASE_URL}/trends/api/widgetdata/comparedgeo",
            params=params,
        )
        data = self._parse_response(resp)

        regions = []
        for region in data.get("default", {}).get("geoMapData", []):
            regions.append({
                "name": region["geoName"],
                "code": region.get("geoCode", ""),
                "value": region["value"][0],
                "max_value_index": region.get("maxValueIndex", 0),
                "has_data": region.get("hasData", [True])[0],
            })
        return sorted(regions, key=lambda r: r["value"], reverse=True)

    def related_queries(self, widgets: list[dict]) -> dict:
        """Get top and rising related search queries."""
        widget = next((w for w in widgets if w["id"] == "RELATED_QUERIES"), None)
        if not widget:
            return {"top": [], "rising": []}

        params = {
            **self.base_params,
            "req": json.dumps(widget["request"]),
            "token": widget["token"],
        }
        resp = self.client.get(
            f"{BASE_URL}/trends/api/widgetdata/relatedsearches",
            params=params,
        )
        data = self._parse_response(resp)

        ranked = data.get("default", {}).get("rankedList", [])
        if len(ranked) < 2:
            return {"top": [], "rising": []}

        top = [
            {"query": r["query"], "value": r["value"][0], "formatted": r.get("formattedValue", "")}
            for r in ranked[0].get("rankedKeyword", [])
        ]
        rising = [
            {"query": r["query"], "value": r["value"][0], "formatted": r.get("formattedValue", "")}
            for r in ranked[1].get("rankedKeyword", [])
        ]
        return {"top": top, "rising": rising}

    def related_topics(self, widgets: list[dict]) -> dict:
        """Get top and rising related topics (entities, not just keyword strings)."""
        widget = next((w for w in widgets if w["id"] == "RELATED_TOPICS"), None)
        if not widget:
            return {"top": [], "rising": []}

        params = {
            **self.base_params,
            "req": json.dumps(widget["request"]),
            "token": widget["token"],
        }
        resp = self.client.get(
            f"{BASE_URL}/trends/api/widgetdata/relatedsearches",
            params=params,
        )
        data = self._parse_response(resp)

        ranked = data.get("default", {}).get("rankedList", [])
        if len(ranked) < 2:
            return {"top": [], "rising": []}

        def parse_topic(r):
            topic = r.get("topic", {})
            return {
                "title": topic.get("title"),
                "type": topic.get("type"),
                "mid": topic.get("mid"),  # Google Knowledge Graph entity ID
                "value": r["value"][0],
                "formatted": r.get("formattedValue", ""),
            }

        return {
            "top": [parse_topic(r) for r in ranked[0].get("rankedKeyword", [])],
            "rising": [parse_topic(r) for r in ranked[1].get("rankedKeyword", [])],
        }

    def close(self):
        self.client.close()

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

Comparing Multiple Keywords

def compare_keywords(
    keywords: list[str],
    geo: str = "",
    time_range: str = "today 12-m",
    proxy: str = None,
) -> dict:
    """
    Compare search interest for multiple keywords over time.
    Returns structured comparison with trend analysis.
    """
    with GoogleTrendsClient(proxy=proxy) as client:
        widgets = client.get_widgets(keywords, geo=geo, time_range=time_range)
        time.sleep(1)  # Be polite between API calls

        timeline = client.interest_over_time(widgets)
        time.sleep(1)

        regions = client.interest_by_region(widgets)
        time.sleep(1)

        queries = client.related_queries(widgets)

    if not timeline:
        return {}

    # Compute statistics per keyword
    stats = []
    for i, kw in enumerate(keywords):
        values = [p["values"][i] for p in timeline if p["values"][i] is not None]
        if not values:
            continue

        peak_point = max(timeline, key=lambda p: p["values"][i] if p["values"][i] else 0)
        recent_avg = sum(p["values"][i] for p in timeline[-4:]) / 4
        prior_avg = sum(p["values"][i] for p in timeline[-8:-4]) / 4 if len(timeline) >= 8 else recent_avg

        stats.append({
            "keyword": kw,
            "current": timeline[-1]["values"][i] if timeline else None,
            "avg": sum(values) / len(values),
            "peak_value": peak_point["values"][i],
            "peak_date": peak_point["date"],
            "recent_avg": recent_avg,
            "prior_avg": prior_avg,
            "trend": "up" if recent_avg > prior_avg * 1.05 else "down" if recent_avg < prior_avg * 0.95 else "stable",
            "change_pct": ((recent_avg - prior_avg) / prior_avg * 100) if prior_avg else 0,
        })

    return {
        "keywords": keywords,
        "geo": geo or "Worldwide",
        "time_range": time_range,
        "timeline": timeline,
        "keyword_stats": stats,
        "top_regions": regions[:10],
        "related_queries": queries,
    }

# Example
result = compare_keywords(
    ["web scraping", "data extraction", "web crawling"],
    geo="US",
    time_range="today 12-m",
)

print("Keyword Comparison Results")
print("=" * 40)
for stat in result["keyword_stats"]:
    print(f"\n{stat['keyword']}:")
    print(f"  Current: {stat['current']}/100")
    print(f"  Average: {stat['avg']:.1f}/100")
    print(f"  Peak: {stat['peak_value']}/100 ({stat['peak_date']})")
    print(f"  Trend: {stat['trend']} ({stat['change_pct']:+.1f}%)")

Full Research Report Generator

import csv
import sqlite3
from datetime import datetime
from pathlib import Path

def full_trends_report(
    keyword: str,
    geo: str = "US",
    proxy: str = None,
    output_dir: str = ".",
) -> dict:
    """
    Generate a complete Google Trends market research report.
    Saves CSV files and returns structured data.
    """
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True)

    print(f"=== Google Trends Report: '{keyword}' ===")
    print(f"Region: {geo} | Generated: {datetime.utcnow().isoformat()}\n")

    with GoogleTrendsClient(proxy=proxy) as client:
        # 12-month trend
        widgets_12m = client.get_widgets([keyword], geo=geo, time_range="today 12-m")
        time.sleep(1.5)

        timeline_12m = client.interest_over_time(widgets_12m)
        time.sleep(1.5)

        queries = client.related_queries(widgets_12m)
        time.sleep(1.5)

        topics = client.related_topics(widgets_12m)
        time.sleep(1.5)

        regions = client.interest_by_region(widgets_12m, resolution="REGION")
        time.sleep(1.5)

        # 5-year trend for seasonality analysis
        widgets_5y = client.get_widgets([keyword], geo=geo, time_range="today 5-y")
        time.sleep(1.5)
        timeline_5y = client.interest_over_time(widgets_5y)

    # --- Analysis ---
    current = timeline_12m[-1]["values"][0] if timeline_12m else 0
    peak = max(timeline_12m, key=lambda p: p["values"][0]) if timeline_12m else {}
    trough = min(timeline_12m, key=lambda p: p["values"][0]) if timeline_12m else {}

    recent_values = [p["values"][0] for p in timeline_12m[-4:]] if timeline_12m else []
    prior_values = [p["values"][0] for p in timeline_12m[-8:-4]] if len(timeline_12m) >= 8 else []
    recent_avg = sum(recent_values) / len(recent_values) if recent_values else 0
    prior_avg = sum(prior_values) / len(prior_values) if prior_values else recent_avg
    change_pct = ((recent_avg - prior_avg) / prior_avg * 100) if prior_avg else 0

    # Seasonality: find which month historically peaks
    monthly_avgs = {}
    for point in timeline_5y:
        try:
            # Date format varies by granularity
            date_str = point["date"]
            month = date_str[:7]  # YYYY-MM
            if month not in monthly_avgs:
                monthly_avgs[month] = []
            monthly_avgs[month].append(point["values"][0])
        except Exception:
            continue

    # Average by calendar month (Jan-Dec)
    cal_month_avgs = {}
    for month_str, values in monthly_avgs.items():
        cal_month = month_str[5:7]  # "01" - "12"
        if cal_month not in cal_month_avgs:
            cal_month_avgs[cal_month] = []
        cal_month_avgs[cal_month].extend(values)
    seasonal_profile = {m: sum(v) / len(v) for m, v in cal_month_avgs.items() if v}
    peak_month = max(seasonal_profile, key=seasonal_profile.get) if seasonal_profile else None

    # --- Output ---
    print(f"Current interest: {current}/100")
    print(f"12-month peak: {peak.get('values', [0])[0]}/100 ({peak.get('date', 'N/A')})")
    print(f"12-month trough: {trough.get('values', [0])[0]}/100 ({trough.get('date', 'N/A')})")
    print(f"Recent trend: {'up' if change_pct > 0 else 'down'} ({change_pct:+.1f}%)")
    if peak_month:
        month_names = {"01":"Jan","02":"Feb","03":"Mar","04":"Apr","05":"May","06":"Jun",
                      "07":"Jul","08":"Aug","09":"Sep","10":"Oct","11":"Nov","12":"Dec"}
        print(f"Seasonal peak month: {month_names.get(peak_month, peak_month)}")

    print(f"\nTop related queries:")
    for q in queries.get("top", [])[:5]:
        print(f"  {q['query']} ({q['formatted']})")

    print(f"\nRising queries (breakout topics):")
    for q in queries.get("rising", [])[:5]:
        print(f"  {q['query']} ({q['formatted']})")

    print(f"\nTop regions:")
    for r in regions[:10]:
        print(f"  {r['name']}: {r['value']}/100")

    # --- Save CSV ---
    csv_path = output_path / f"{keyword.replace(' ', '_')}_trends.csv"
    with open(csv_path, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["date", "interest"])
        for point in timeline_12m:
            writer.writerow([point["date"], point["values"][0]])
    print(f"\n12-month data saved to {csv_path}")

    return {
        "keyword": keyword,
        "geo": geo,
        "current": current,
        "peak": peak,
        "trough": trough,
        "change_pct": change_pct,
        "peak_season_month": peak_month,
        "top_queries": queries.get("top", [])[:10],
        "rising_queries": queries.get("rising", [])[:10],
        "top_topics": topics.get("top", [])[:10],
        "rising_topics": topics.get("rising", [])[:10],
        "top_regions": regions[:15],
        "timeline_12m": timeline_12m,
    }

# Generate report
report = full_trends_report("web scraping", geo="US")

Tracking Trends Over Time (SQLite Storage)

For continuous monitoring, store snapshots to track keyword interest over weeks and months:

import sqlite3

def init_trends_db(db_path: str = "trends_monitor.db") -> sqlite3.Connection:
    """Initialize database for trend monitoring."""
    conn = sqlite3.connect(db_path)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS interest_snapshots (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            keyword TEXT NOT NULL,
            geo TEXT DEFAULT '',
            date_label TEXT NOT NULL,
            interest INTEGER NOT NULL,
            captured_at TEXT DEFAULT (datetime('now')),
            UNIQUE(keyword, geo, date_label)
        )
    """)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS related_queries (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            keyword TEXT NOT NULL,
            geo TEXT DEFAULT '',
            query_type TEXT NOT NULL,
            related_query TEXT NOT NULL,
            value INTEGER,
            captured_at TEXT DEFAULT (datetime('now'))
        )
    """)
    conn.execute("""
        CREATE INDEX IF NOT EXISTS idx_keyword_geo
        ON interest_snapshots(keyword, geo)
    """)
    conn.commit()
    return conn

def save_trend_snapshot(
    conn: sqlite3.Connection,
    keyword: str,
    geo: str,
    timeline: list[dict],
    queries: dict,
):
    """Save a trend snapshot to the database."""
    # Save timeline data
    rows = [
        (keyword, geo, p["date"], p["values"][0])
        for p in timeline
        if p.get("values")
    ]
    conn.executemany(
        "INSERT OR REPLACE INTO interest_snapshots (keyword, geo, date_label, interest) VALUES (?, ?, ?, ?)",
        rows,
    )

    # Save related queries
    query_rows = []
    for query_type, query_list in queries.items():
        for q in query_list[:20]:
            query_rows.append((keyword, geo, query_type, q["query"], q.get("value", 0)))
    if query_rows:
        conn.executemany(
            "INSERT INTO related_queries (keyword, geo, query_type, related_query, value) VALUES (?, ?, ?, ?, ?)",
            query_rows,
        )

    conn.commit()

def monitor_keywords(
    keywords: list[str],
    geo: str = "US",
    interval_hours: int = 24,
    proxy: str = None,
    db_path: str = "trends_monitor.db",
):
    """
    Monitor a list of keywords indefinitely, saving daily snapshots.
    Run this in a cron job or background process.
    """
    conn = init_trends_db(db_path)
    client = GoogleTrendsClient(proxy=proxy)

    for keyword in keywords:
        try:
            widgets = client.get_widgets([keyword], geo=geo, time_range="today 3-m")
            time.sleep(1.5)
            timeline = client.interest_over_time(widgets)
            time.sleep(1.5)
            queries = client.related_queries(widgets)

            save_trend_snapshot(conn, keyword, geo, timeline, queries)
            print(f"Saved snapshot for '{keyword}': {len(timeline)} data points")
        except Exception as e:
            print(f"Error tracking '{keyword}': {e}")

        time.sleep(random.uniform(2, 5))

    client.close()
    conn.close()

Batch Comparison with Anchor Keywords

For comparing more than 5 keywords, use an anchor keyword across batches:

def batch_compare(
    keywords: list[str],
    anchor: str,
    geo: str = "US",
    time_range: str = "today 12-m",
    proxy: str = None,
) -> dict[str, list]:
    """
    Compare an unlimited number of keywords using a shared anchor.

    Each batch is compared against the anchor keyword. The anchor's
    relative values allow normalization across batches.

    Args:
        keywords: Any number of keywords to compare
        anchor: A stable, well-known keyword to use as the reference
        geo: Geography filter
        time_range: Time range
        proxy: Optional proxy URL

    Returns:
        Dict mapping each keyword to its normalized interest over time
    """
    results = {}

    # Get anchor baseline
    with GoogleTrendsClient(proxy=proxy) as client:
        anchor_widgets = client.get_widgets([anchor], geo=geo, time_range=time_range)
        time.sleep(1.5)
        anchor_timeline = client.interest_over_time(anchor_widgets)

    anchor_values = {p["date"]: p["values"][0] for p in anchor_timeline}
    results[anchor] = anchor_timeline

    # Process in batches of 4 (leave 1 slot for anchor)
    batch_size = 4
    for i in range(0, len(keywords), batch_size):
        batch = keywords[i:i + batch_size]
        batch_with_anchor = [anchor] + batch

        with GoogleTrendsClient(proxy=proxy) as client:
            widgets = client.get_widgets(
                batch_with_anchor, geo=geo, time_range=time_range
            )
            time.sleep(1.5)
            timeline = client.interest_over_time(widgets)

        # anchor_idx = 0 in this batch
        for kw_idx, kw in enumerate(batch, start=1):
            normalized = []
            for point in timeline:
                anchor_val = point["values"][0]
                kw_val = point["values"][kw_idx]
                # Normalize against anchor_values from the single-anchor run
                reference = anchor_values.get(point["date"], 1)
                if anchor_val > 0 and reference > 0:
                    adjusted = kw_val * (reference / anchor_val)
                else:
                    adjusted = kw_val
                normalized.append({"date": point["date"], "value": int(adjusted)})
            results[kw] = normalized

        print(f"Batch {i // batch_size + 1}: {batch}")
        time.sleep(random.uniform(3, 6))

    return results

# Compare 12 keywords using "python" as anchor
all_results = batch_compare(
    keywords=[
        "web scraping tutorial", "playwright python", "beautifulsoup",
        "scrapy framework", "selenium python", "httpx python",
        "proxy rotation python", "residential proxy", "data extraction",
        "screen scraping", "web crawler python", "parse html python",
    ],
    anchor="python",
    geo="US",
)

Exporting to CSV

import csv
from pathlib import Path

def export_timeline_csv(
    keywords: list[str],
    geo: str = "",
    time_range: str = "today 12-m",
    output: str = "trends_data.csv",
    proxy: str = None,
):
    """Export interest-over-time data for multiple keywords to CSV."""
    with GoogleTrendsClient(proxy=proxy) as client:
        widgets = client.get_widgets(keywords, geo=geo, time_range=time_range)
        time.sleep(1)
        timeline = client.interest_over_time(widgets)

    with open(output, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["date"] + keywords)
        for point in timeline:
            writer.writerow([point["date"]] + point["values"])

    print(f"Exported {len(timeline)} data points to {output}")
    return output

def export_all_data(
    keyword: str,
    geo: str = "US",
    output_dir: str = "trends_export",
    proxy: str = None,
):
    """Export all available data for a keyword to multiple CSV files."""
    Path(output_dir).mkdir(exist_ok=True)

    with GoogleTrendsClient(proxy=proxy) as client:
        widgets = client.get_widgets([keyword], geo=geo)
        time.sleep(1)

        # Timeline
        timeline = client.interest_over_time(widgets)
        time.sleep(1)

        # Regions
        countries = client.interest_by_region(widgets, resolution="COUNTRY")
        time.sleep(1)
        regions = client.interest_by_region(widgets, resolution="REGION")
        time.sleep(1)

        # Queries
        queries = client.related_queries(widgets)
        time.sleep(1)
        topics = client.related_topics(widgets)

    base = f"{output_dir}/{keyword.replace(' ', '_')}"

    with open(f"{base}_timeline.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["date", "interest"])
        writer.writeheader()
        writer.writerows([{"date": p["date"], "interest": p["values"][0]} for p in timeline])

    with open(f"{base}_countries.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["name", "code", "value"])
        writer.writeheader()
        writer.writerows(countries)

    with open(f"{base}_queries_top.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["query", "value", "formatted"])
        writer.writeheader()
        writer.writerows(queries["top"])

    print(f"Exported all data to {output_dir}/")

Time Parameter Reference

Category Codes

Filter by category to remove ambiguous results. For "Java", use the programming category to exclude the island and the coffee:

Gotchas

Relative values only. Google Trends returns values on a 0-100 scale, not absolute search volumes. The peak value in your time range is always 100, everything else is relative. Comparing across different queries requires requesting them together in the same comparisonItem array — separate requests normalize independently.

Token expiration. Widget tokens expire after a few minutes. Don't cache them between requests. Always fetch fresh tokens from the explore endpoint.

Comparison limit. You can compare up to 5 keywords at once. For larger comparisons, use the batch_compare function above with a common anchor keyword.

Data availability lag. Real-time data ("now 1-H") has a 2-3 minute lag. Daily granularity data may take 24-48 hours to finalize. Historical data beyond 5 years is only available at monthly granularity.

Empty data for niche terms. Very low-volume searches return null or 0 for most time points. Google anonymizes data where the volume is too low to preserve privacy. This shows up as hasData: false in the response.

Rate limiting. Making more than ~30 requests per hour from a single IP triggers 429s. Use 2-3 second delays between calls. For automated pipelines, route through ThorData's residential proxies to spread requests across multiple IPs.

Business Use Cases

Content Strategy and SEO

Before writing blog posts, check Google Trends to validate topic demand. Compare keyword variations to find the highest-interest phrasing. Track seasonal patterns to time your content calendar — if "web scraping tutorial" peaks every January, publish your guide in December.

Product-Market Fit Validation

Before building a product, check if demand is growing or declining. Compare your category against alternatives. If "no-code automation" interest is rising while "RPA software" is flat, that signals where the market is heading.

Geographic Expansion

Use interest-by-region data to identify underserved markets. If your SaaS tool has high interest in Brazil but you only market in English, that's a localization opportunity with validated demand.

Trend-Based Content and Advertising

Rising related queries reveal what users are searching for RIGHT NOW. Build content around these before competitors do. A rising query showing "+350%" means the topic is exploding but not yet saturated.

Competitive Intelligence

Track brand name search interest over time. Compare your product against competitors to see relative mindshare. Sustained growth in a competitor's branded search interest signals they're doing something right.

See also: Scraping Google Search Results | Web Scraping APIs Comparison