Google Trends API: the official alpha, pytrends alternatives and pricing

Google has an official Trends API, but it's an alpha you have to apply for, and Google has published no pricing or release date. pytrends, the unofficial Python library most tutorials still use, was archived on April 17, 2025 and is now read-only. For production code today, the practical route is a managed API: SerpApi or SearchApi for every Explore chart, DataForSEO for the lowest price per request, Glimpse for absolute search volumes, or Cite42 for one-term Trends requests at $0.05 each over REST or MCP, with no subscription.

Cite42 publishes this guide. We ran the two Cite42 requests shown here on October 5, 2026, and researched the other APIs from their official documentation and pricing pages on October 6, 2026, without paid tests.

The best Google Trends APIs for different jobs

• Google Trends API alpha: consistently scaled data you can merge across requests, if Google accepts your application.
• Cite42: one term's interest over time and related queries for $0.05 a request, billed per call with no subscription, from code or from Claude, ChatGPT, Codex and Cursor over MCP.
• SerpApi: the easiest move from pytrends, with up to five terms per chart, region breakdowns and related topics.
• SearchApi: the same Explore data types at a lower price per search on a monthly plan.
• DataForSEO: the lowest price per request for large batch jobs, after a $50 minimum deposit.
• Glimpse: estimated absolute search volume next to the 0 to 100 index.

Comparison at a glance

Apify's Google Trends Scraper is another pay-per-result option, from $0.30 per 1,000 results plus Apify platform usage. Pricing sources are linked in each section below.

Google Trends API alpha: the official option

Google announced the Google Trends API alpha on July 24, 2025. It returns consistently scaled search interest, so you can compare and merge results across requests instead of working with the website's 0 to 100 index, which is rescaled for every query. It covers a rolling five-year window up to two days ago, with daily, weekly, monthly and yearly aggregation and breakdowns by region and subregion.

Access is the catch. As of October 2026, the API page is still taking alpha applications and says Google is prioritizing developers who know what they want to build, can start soon and will give feedback. There's no published pricing or quota. Apply if consistent scaling matters to your analysis, and build on a managed API in the meantime.

What happened to pytrends

pytrends was an unofficial Python wrapper around the endpoints the Google Trends website calls. Its own README said it was "only good until Google changes their backend again", called the rate limit unknown and suggested a 60-second pause once you hit it. The owner archived the repository on April 17, 2025, so it gets no more fixes.

Forks and newer scraping libraries share that weakness: they depend on unofficial endpoints that Google can change or block whenever it likes. A managed API hands the maintenance, proxies and retries to a vendor that's paid to keep them working.

Cite42: one-term Trends requests over REST or MCP

Cite42 is a pay-per-call API and MCP server for Google Trends, keyword search volume and AI visibility data. One Trends request takes a single term, a timeframe and an optional location and language. It returns the interest series, a rising, falling or stable label, and the rising and top related queries. Each successful request costs $0.05.

There is no subscription or monthly fee. You top up a prepaid balance (minimum $25.00), the balance never expires, and you pay only for successful calls. A verified signup includes $1.00 of free credit. The same tool works in Claude, ChatGPT, Codex and Cursor through Cite42's hosted MCP server, which the Google Trends MCP guide walks through.

Pros

• One call returns the interest series and related queries, which SerpApi and SearchApi bill as separate searches.
• No subscription or minimum monthly spend, and unused balance never expires.
• The same API key covers keyword search volume from Google Ads Keyword Planner and AI visibility checks.

Cons

• One term per request: no multi-term chart on a shared scale, no interest by region and no related topics.
• Values are Google's relative 0 to 100 index, and related queries come without growth percentages.
• At high volume it costs more per request than DataForSEO direct or a SerpApi or SearchApi plan.

Here is a request for "Google Trends" in the UK over the past 12 months, the same input as our October 5 research. Keep your key in an environment variable:

curl --fail-with-body https://www.cite42.dev/api/v1/trends \
  -H "Authorization: Bearer $CITE42_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "term": "Google Trends",
    "timeframe": "past_12_months",
    "geo": "United Kingdom",
    "language": "en"
  }'

timeframe accepts tokens such as past_7_days, past_30_days, past_90_days, past_12_months (the default) and past_5_years. Anything else falls back to 12 months, so validate it in your client. geo takes a location name such as "United Kingdom" and defaults to the United States. The response echoes the term it measured, which matters when you send a long phrase and the tool reduces it to a shorter lookup term. Every parameter is in the Trends API reference.

SerpApi: the closest match to pytrends

SerpApi's Google Trends API mirrors the Trends website closely, which makes it the easiest migration from pytrends. The data_type parameter picks interest over time (TIMESERIES) or a compared breakdown by region (GEO_MAP) for up to five terms, or interest by region (GEO_MAP_0), related queries and related topics for one term. You can filter by geo, date, category (cat) and property (gprop: web, images, news, shopping or YouTube).

SerpApi's pricing starts with 250 free searches a month, then $25 a month for 1,000 searches or $75 for 5,000. Only successful searches count, and cached searches are free.

Pros

• Every Explore chart type, with the same filters as the website.
• 250 free searches a month, and repeat requests served from cache cost nothing.

Cons

• A monthly subscription once you outgrow the free tier.
• Each data type is a separate search, so a series, its related queries and a region map take three.

SearchApi: Explore data on a monthly plan

SearchApi's Google Trends API offers four data types: TIMESERIES and GEO_MAP with up to five comma-separated terms, plus RELATED_QUERIES and RELATED_TOPICS, with geo, time, cat and gprop filters. The Developer plan is $40 a month for 10,000 searches, far cheaper per search than SerpApi's entry plans, and new accounts get 100 free requests. Failed requests are free.

Pros

• A low cost per search once you're on a plan, with the same data types and filters as SerpApi.

Cons

• Every plan beyond the trial is a monthly subscription, and each data type is a separate search.

DataForSEO: the lowest price per request

DataForSEO's Google Trends API wraps the Explore page with up to five keywords per task. One task can return the interest graph, the region map, related topics and related queries, for web, news, YouTube, image or shopping searches. A live task costs $0.011, and a queued task that returns within 45 minutes costs $0.0027. Billing is pay-as-you-go with no subscription, the balance doesn't expire, and the minimum payment is $50.

If you're processing thousands of terms and are happy to write your own parser, DataForSEO is the cheapest per request.

Pros

• The lowest per-request price here, especially in queued mode.
• All four Explore data types and up to five terms in one task.

Cons

• A $50 minimum deposit before the first call.
• A lower-level response: each item type has its own data shape, so parsing takes more code.

Glimpse: absolute search volume

Glimpse adds estimated absolute search volume to Google Trends. Its API has two endpoints: interest over time on the familiar 0 to 100 index, and search volume over time, both filterable by country and by daily, weekly or monthly resolution. It's the option to pick when the question is "how many searches", which every other API here leaves to you. Glimpse publishes no API pricing; you request a key and contact the company about limits.

Pros

• Absolute volume estimates alongside the relative index.

Cons

• One keyword per request, and pricing only on request.

You can also get scale by pairing a Trends series with a keyword volume API, which our keyword research API comparison covers.

Google Trends API in Python without pytrends

This example replaces a pytrends interest_over_time() and related_queries() pair with a single Cite42 request. It uses requests and reads the key from CITE42_API_KEY:

import os

import requests


def google_trends(term, geo="United States", timeframe="past_12_months"):
    response = requests.post(
        "https://www.cite42.dev/api/v1/trends",
        headers={"Authorization": f"Bearer {os.environ['CITE42_API_KEY']}"},
        json={"term": term, "geo": geo, "timeframe": timeframe},
        timeout=90,
    )
    response.raise_for_status()
    return response.json()


data = google_trends("google trends", geo="United Kingdom")
print(data["term"], data["trend"], len(data["interestOverTime"]), "points")
for point in data["interestOverTime"][-3:]:
    print(point["date"], point["value"])
print("Rising:", ", ".join(data["risingQueries"][:5]))

raise_for_status() turns an error response into an exception, and errors are never billed. If you used pytrends for its DataFrame, pandas.DataFrame(data["interestOverTime"]) gives you date and value columns ready to plot.

When you port pytrends code to a managed API, these are the equivalents:

pytrends' build_payload() took up to five keywords at once. In Cite42 you make one request per term.

A typed TypeScript client

For a Node or Next.js backend, this client constrains the timeframe at the type level and checks the series shape at runtime before you store it:

type Timeframe = 'past_7_days' | 'past_30_days' | 'past_90_days' | 'past_12_months' | 'past_5_years';

interface TrendsInput {
  term: string;
  timeframe: Timeframe;
  geo?: string;
  language?: string;
}

interface TrendsPoint {
  date: string;
  value: number;
}

function isPoint(value: unknown): value is TrendsPoint {
  return typeof value === 'object' && value !== null
    && 'date' in value && typeof value.date === 'string'
    && 'value' in value && typeof value.value === 'number'
    && Number.isFinite(value.value);
}

export async function readTrends(input: TrendsInput, apiKey: string) {
  const response = await fetch('https://www.cite42.dev/api/v1/trends', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(input),
  });
  if (!response.ok) {
    throw new Error(`Cite42 Trends returned HTTP ${response.status}`);
  }

  const result: unknown = await response.json();
  if (typeof result !== 'object' || result === null
    || !('term' in result) || typeof result.term !== 'string'
    || !('interestOverTime' in result)
    || !Array.isArray(result.interestOverTime)
    || !result.interestOverTime.every(isPoint)) {
    throw new Error('Unexpected Trends response shape');
  }

  return {
    requested: input,
    measuredTerm: result.term,
    retrievedAt: new Date().toISOString(),
    series: result.interestOverTime,
    raw: result,
  };
}

Keep the key on the server. retrievedAt records when you fetched the data: Cite42 caches identical Trends requests for 24 hours, so a repeat within that window returns the same series and is billed like any successful call.

Read the values and the trend label correctly

Both of our October 5 requests returned 53 weekly points, from October 5, 2025 to October 4, 2026:

A value of 100 is the highest point in that one series, not 100 searches. Each country is scaled to its own peak, so the UK's 16 and the US's 14 say nothing about which market searched more. The UK series is labeled rising even though it ended at its lowest point, because Cite42's label compares the average of the first quarter of points with the average of the last quarter and calls a change of more than 10% rising or falling. Show the series next to the label, and avoid reading "rising" as a forecast. The Google Trends MCP guide walks through both series in detail, and the raw responses are in the evidence file.

Three habits keep stored Trends data usable:

• Save the term, location, language, timeframe, provider and retrieval time with every full series.
• Re-fetch the whole window instead of appending new points to an old series. When a new peak enters a rolling window, every older value is rescaled against it.
• Treat an empty interestOverTime array as missing data. The label defaults to stable when there are too few points, so check the point count before you show it.

If you later move to Google's consistently scaled alpha, revisit any logic built around the 0 to 100 index.

What a Trends job costs

Take ten terms in two countries, with the interest series and related queries for each. That's 20 term and country pairs:

• Cite42: 20 requests, $1.00 at current prices, with related queries included. Our two-country example cost $0.10 on October 5, 2026.
• SerpApi: 40 searches (series plus related queries), inside the free 250 a month.
• SearchApi: 40 searches, inside the 100-request trial or a small slice of the Developer plan.
• DataForSEO: 20 live tasks for about $0.22, once you've made the $50 minimum deposit.

For small, occasional jobs, SerpApi's free tier is the cheapest way in. Cite42 suits you when you'd rather pay per call with no plan to manage, or when Trends sits next to keyword volume and AI visibility checks in one workflow.

Frequently asked questions

Is there an official Google Trends API?

Yes, but only as an alpha. Google opened applications for the Google Trends API on July 24, 2025, and as of October 2026 access is limited to accepted testers, with no public pricing. Until you're accepted, managed APIs such as SerpApi, SearchApi, DataForSEO and Cite42 are the practical way to get Trends data in code.

What can I use instead of pytrends?

pytrends was archived on April 17, 2025. SerpApi is the closest replacement because it mirrors the Trends website's charts and filters. Cite42 returns one term's interest series and related queries for $0.05 per request with no subscription, and DataForSEO is the cheapest per request at scale. All three return JSON you can load into pandas.

Is there a free Google Trends API?

SerpApi includes 250 free searches a month, and SearchApi gives new accounts 100 free requests. Cite42 adds $1.00 of free credit on verified signup, after which each Trends request costs $0.05 from a balance that never expires. Google's official alpha has no published pricing.

How do I get Google Trends data in Python?

Send a POST request with the requests library to a managed Trends API and read the JSON. The example in this guide calls Cite42's /api/v1/trends endpoint with a term, location and timeframe, then prints the trend label, the latest points and the rising queries.

Does any Google Trends API return absolute search volume?

Glimpse's API returns estimated absolute search volume alongside the 0 to 100 index. Google's alpha returns consistently scaled values that you can compare across requests. Otherwise, pair a Trends series with a keyword volume API such as Cite42's, which reports average monthly search volume per keyword.

Start with one term and one market

Create a Cite42 account for $1.00 of starter credit, add an API key from the dashboard and run the Python or curl example for a term you care about. The Trends API reference lists every parameter, and the Google Trends MCP guide shows the same data inside Claude.