DEV Community: Meridian Labs Software

Google Trends in Python after pytrends: bulk keywords without 429 errors

Meridian Labs Software — Wed, 30 Sep 2026 12:43:59 +0000

If you've used pytrends for anything bigger than a handful of keywords, you know how it goes. The first ten requests are fine, then TooManyRequestsError: The request failed: Google returned a response with code 429, then you add time.sleep(60), then you start looking at proxy providers.

And now there's a second problem. The pytrends repo on GitHub was archived in April 2025, and its last code push was in August 2024. It still installs, but nobody is fixing it when Google changes something.

So what are the options in 2026?

Option 1: keep pytrends and slow down

This still works for small jobs. Keep one keyword per request, sleep between calls, and back off hard when you see a 429. For 20 keywords a week it's fine. For 500 keywords, or anything on a schedule, you'll spend more time babysitting it than using the data. You're also sending every request from your own IP, which is why the 429s show up so fast.

Option 2: Google's official Trends API

Google announced an official Trends API in July 2025. At the time of writing it's an alpha for a limited group of testers, and there's no public sign-up. Worth applying if you have a real use case, but you can't build on it today.

Option 3: a hosted scraper you call like an API

This is what I ended up building, so take this section with that in mind: I made the Google Trends Scraper on Apify for exactly this problem. You send a list of keywords, it handles the proxies and retries on its side, and you get one row per keyword back. You never deal with a 429.

Here's the whole thing in Python. pip install apify-client, then grab an API token from the Apify Console (Settings > API & Integrations).

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("meridianlabs/google-trends-scraper").call(run_input={
    "keywords": ["halloween costume", "pickleball", "air fryer", "standing desk"],
    "geo": "US",
    "timeRange": "past_5_years",
})

for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["keyword"], "|", row["summary"]["text"])

That's apify-client 3.x. On 2.x use run["defaultDatasetId"].

I ran exactly that today (30 September 2026). It took about 20 seconds for all four:

halloween costume | Interest is rising (+391% vs the previous 13 weeks); up 3% year on year. Peak: October 2021. Seasonal: peaks every October. Fastest-rising related search: '2024 halloween costume ideas' (Breakout).
pickleball | Interest is falling (-29% vs the previous 13 weeks); down 2% year on year. Peak: April 2026. Fastest-rising related search: 'joola pickleball paddle' (Breakout).
air fryer | Interest is falling (-20% vs the previous 13 weeks); up 11% year on year. Peak: January 2022. Fastest-rising related search: 'shop air fryer deals' (Breakout).
standing desk | Interest is falling (-66% vs the previous 13 weeks); up 29% year on year. Peak: April 2026. Fastest-rising related search: 'vernal standing desk' (Breakout).

(Google Trends samples its data, so a second run a few minutes later gave standing desk -65% and +31%. Expect the odd point of drift between runs; the direction doesn't change.)

The raw data is still there. Each row has the full interestOverTime series, interestByRegion and relatedQueries (top and rising), same as pytrends. The summary line is the part I added, because with 500 keywords I don't want 500 charts. I want to know which ones are going up right now.

Moving pytrends code over

pytrends	This
`interest_over_time()`	`row["interestOverTime"]`
`interest_by_region()`	`row["interestByRegion"]`
`related_queries()`	`row["relatedQueries"]`
`timeframe='today 5-y'`	`"timeRange": "past_5_years"`
`geo='US'`	`"geo": "US"` (same codes, including `US-CA`)
`build_payload(kw_list=[...5 terms])` to compare	`"compareKeywords": true`, in groups of up to 5 (Google's limit), as many groups as you like

Every data type comes back in one lookup, so there's no separate request per method like with pytrends.

Filtering 500 keywords down to the ones that matter

The summary is also split into plain fields, so you can filter without parsing text: momentum (rising, falling or stable), recentChangePct, yearOnYearChangePct, seasonal, seasonalPeakMonth, peakDate and topRisingQuery.

I put a small script on GitHub that reads keywords.txt, writes everything to a CSV and prints the rising and seasonal ones: pytrends-alternative. The core of it:

rows = [{"keyword": i["keyword"], **i["summary"]}
        for i in client.dataset(run.default_dataset_id).iterate_items()]

rising = [r["keyword"] for r in rows if r["momentum"] == "rising"]
seasonal = [(r["keyword"], r["seasonalPeakMonth"]) for r in rows if r["seasonal"]]

On my four test keywords that prints Rising now: halloween costume and Seasonal: halloween costume (October), which is what you'd hope for at the end of September.

What it costs, and what it can't do

It's $0.005 per keyword lookup, so 1,000 keywords is $5, and failed lookups aren't charged. Apify's free plan includes $5 of usage a month, which covers about 1,000 lookups, so you can try it on a real list before paying anything.

Things it won't do:

Related topics. Google doesn't return these to automated lookups, so only related searches (queries) come back.
City-level regions. Countries, states and US metro areas work. Cities don't.
Absolute search volume. Google Trends is a 0 to 100 index, not search counts. If you need monthly volumes, you need a Keyword Planner-type source instead.
Brand-new or tiny terms can come back as no_data. That's Google having nothing, not an error.

If you're still on pytrends and it's working for your volume, there's no reason to switch. If you're fighting 429s or building something that runs on a schedule, this is the setup I'd use.

pytrends is dead. Here's a maintained drop-in replacement

Meridian Labs Software — Mon, 28 Sep 2026 14:23:50 +0000

pytrends stopped getting updates in April 2025

If you've used pytrends to pull Google Trends data, you've probably noticed it's gotten flakier over the last year. That's because the repo was archived by its owner in April 2025 — no more fixes, ever.

The core problem it never solved well: pytrends fires every request straight from your own IP with no cookie handling, so as soon as you run more than a handful of lookups you get hit with Google's 429 Too Many Requests.

What I built

google-trends-api-python is a drop-in replacement that keeps pytrends' exact interface (TrendReq, build_payload, interest_over_time(), all the same DataFrame shapes) but routes requests through a hosted backend instead of your machine. Proxies and retries run server-side, so there's nothing to handle yourself.

Swap two lines:

from google_trends_api import TrendReq  # was: from pytrends.request import TrendReq

pytrends = TrendReq(hl="en-US", tz=360, apify_token="<YOUR_APIFY_TOKEN>")
pytrends.build_payload(["air fryer", "standing desk"], timeframe="today 12-m", geo="US")
df = pytrends.interest_over_time()

Everything else — interest_by_region(), related_queries(), timeframe strings, gprop — works the same as pytrends. There's a full mapping table in the README for anything that changed.

Bonus: bulk mode, and a summary() pytrends never had

For more than a handful of keywords there's a second class that batches hundreds of lookups in one call:

from google_trends_api import GoogleTrends

gt = GoogleTrends(max_cost_usd=2.00)
res = gt.lookup(
    ["halloween costume", "pool float", "ski jacket", "sunscreen"],
    geo="US",
    timeframe="today 5-y",
)

print(res.summary()[["momentum", "yearOnYearChangePct", "seasonal", "seasonalPeakMonth"]])

summary() gives you momentum, year-on-year change, seasonality and peak month per keyword, computed server-side — nothing pytrends had.

The honest bit: it's not free

This isn't a "free API" trick. It calls a hosted Actor on Apify ($0.005 per keyword lookup), and Apify's free plan gives you $5/month, so roughly 1,000 lookups before you'd pay anything. Figured that's worth saying upfront rather than people finding out after installing.

I built a plain-text "art director" so my AI images stop changing when I edit them

Meridian Labs Software — Thu, 17 Sep 2026 09:13:37 +0000

If you make images with AI, you know the specific pain: the first generation is easy. Editing it is where everything falls apart.

I make YouTube thumbnails and playlist covers. I'd get a result I liked, ask to change one small thing — "make the jacket blue" — and get back a completely different picture. New face. New background. New lighting. The one thing I asked for, plus ten I didn't.

After the hundredth time, I realized the problem isn't the model — it's the prompt. When you say "change the jacket," the model has no idea what you want to keep, so it re-rolls the whole scene. The fix is to spell out, every time, what stays locked and what changes, in language the model actually follows.

That's tedious by hand, so I turned it into a plain-text bundle you paste into ChatGPT or Claude. You describe what you want; it writes the direction — one ready-to-paste prompt that says exactly what to preserve and what to change. No code, no API, nothing to install.

Clearest example — same street photo, one instruction ("add falling snow"):

The snow appears; the houses, the road, the parked vans stay exactly as they were. Most tools hand you a brand-new street.

It can also diagnose a render that came out wrong — what's off, why, what to change, and what to keep:

How it works (no magic): it's plain-text reasoning, not a model or an integration. It works out how much detail a request needs, separates what's immutable from what you're changing, and phrases the result for the renderer (ChatGPT / GPT Image by default). Because ChatGPT re-renders the whole frame instead of inpainting, the trick is to restate the locked parts explicitly.

Honest limits: it's tuned and tested on ChatGPT / GPT Image; the Midjourney, Gemini, Ideogram and FLUX profiles are starting points, not verified. And no prompt makes a whole-frame renderer do true local edits — it's a strong mitigation, not a guarantee.

The free version is on GitHub and takes about a minute to try. There's a $19 one-time Pro bundle with the full preservation system, the edit-state ledger, precise single-element edits and deep diagnosis — but the free one shows the whole idea.

Free on GitHub: https://github.com/leewilliam200/visual-director-lite

Would genuinely love feedback — especially where the "keep everything else the same" logic breaks for you. What's the one thing you always want an AI editor to preserve that it never does?