DEV Community: Wrenfield Data

Add an AI-visibility regression test to your CI: fail the build when ChatGPT stops recommending you

Wrenfield Data — Wed, 28 Oct 2026 15:30:03 +0000

Disclosure: I build the AI Search Visibility Tracker Actor used here on Apify. The output below is a real run (October 22, 2026, US, English, HubSpot as the tracked brand, Salesforce and Pipedrive as competitors). The test was run for real against those saved rows with pytest; I did not make new calls for this post.

You test your code on every commit. You probably do not test the thing that now sends a growing share of buyers your way: whether ChatGPT and Perplexity still name your product when someone asks for a recommendation.

This post adds a small pytest file that fails when your brand's mention rate or your own-domain citation rate falls under a threshold. It is meant to run on a schedule (weekly is plenty), not on every push.

What the tracker returns

Each run gives you one check row per prompt per engine, plus summary rows with the rates already computed. The summary row for the tracked brand across both engines looked like this (real values):

{
  "type": "summary", "engine": "all", "brand": "HubSpot", "is_your_brand": true,
  "checks": 2, "answers": 2, "mentions": 2, "mention_rate": 1,
  "share_of_voice": 0.3333, "avg_position": 1, "top_position_rate": 1,
  "citations": 2, "citation_rate": 1,
  "sentiment_positive": 2, "sentiment_negative": 0
}

and the competitor rows have the same shape (is_your_brand: false), so you can also assert that a competitor is not suddenly first. The per-answer check rows carry brand_mentioned, brand_position, competitors_mentioned, your_cited_urls and cited_domains.

The test

"""AI-visibility regression test: fails when AI assistants stop recommending your brand.
Live mode:   APIFY_TOKEN=... pytest -q test_ai_visibility.py      (costs about $0.04 per prompt per engine)
Offline mode: AI_VIS_FIXTURE=tracker_rows.json pytest -q test_ai_visibility.py   (replays saved rows, free)"""
import json, os
import pytest
import requests

BRAND, DOMAIN = "HubSpot", "hubspot.com"
COMPETITORS = ["Salesforce | salesforce.com", "Pipedrive | pipedrive.com"]
PROMPTS = ["What is the best CRM for a small business?"]
ENGINES = ["chatgpt", "perplexity"]
MIN_MENTION_RATE = 0.5      # share of answers that must name the brand
MIN_CITATION_RATE = 0.5     # share of answers that must cite your domain

@pytest.fixture(scope="session")
def rows():
    if os.environ.get("AI_VIS_FIXTURE"):
        return json.load(open(os.environ["AI_VIS_FIXTURE"]))
    r = requests.post(
        "https://api.apify.com/v2/acts/wrenfield-data~ai-search-visibility-tracker/run-sync-get-dataset-items",
        params={"maxTotalChargeUsd": 2.00},     # hard cap: the test can never spend more than $2
        headers={"Authorization": f"Bearer {os.environ['APIFY_TOKEN']}"},
        json={"brands": [BRAND], "domains": [DOMAIN], "competitors": COMPETITORS,
              "prompts": PROMPTS, "engines": ENGINES}, timeout=600)
    r.raise_for_status()
    return r.json()

@pytest.fixture(scope="session")
def mine(rows):
    s = [x for x in rows if x.get("type") == "summary" and x.get("engine") == "all" and x.get("is_your_brand")]
    assert s, "no summary row for your brand: the run failed or returned no answers"
    return s[0]

def test_answers_came_back(rows):
    ok = [x for x in rows if x.get("type") == "check" and x.get("status") == "ok"]
    assert len(ok) >= len(PROMPTS) * len(ENGINES) / 2, "more than half of the checks failed; do not trust the result"

def test_brand_is_named(mine):
    assert mine["mention_rate"] >= MIN_MENTION_RATE, f"{BRAND} named in only {mine['mention_rate']:.0%} of answers"

def test_own_domain_is_cited(mine):
    assert mine["citation_rate"] >= MIN_CITATION_RATE, f"{DOMAIN} cited in only {mine['citation_rate']:.0%} of answers"

Two modes: live (calls the Actor, capped at $2 per run by maxTotalChargeUsd) and offline (replays saved rows for free, which is how you develop the test and how I ran it for this post).

Real output of the offline run:

test_ai_visibility.py::test_answers_came_back PASSED                     [ 33%]
test_ai_visibility.py::test_brand_is_named PASSED                        [ 66%]
test_ai_visibility.py::test_own_domain_is_cited PASSED                   [100%]
============================== 3 passed in 0.07s ===============================

Making it a scheduled job

A GitHub Actions workflow on a weekly cron is enough:

on:
  schedule: [{cron: "0 14 * * 1"}]   # Mondays
jobs:
  ai-visibility:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: pip install pytest requests
      - run: pytest -q test_ai_visibility.py
        env:
          APIFY_TOKEN: ${{ secrets.APIFY_TOKEN }}

(I have not run this workflow file; the pytest file above is what I executed.)

Things that will bite you

Answers are not deterministic. The same prompt gets a different answer next run. One prompt on two engines, as in my example, is a demo; for a real gate use 10 or more prompts across the engines you care about and set the threshold from a few baseline runs, not from a guess.
Cost. The tracker is $0.04 per prompt per engine at the time of writing (scheduled to become $0.06 on November 2, 2026). Ten prompts on two engines is 20 checks: $0.80 today, $1.20 after the change. Weekly, that is about $3.50 to $5.20 a month, and maxTotalChargeUsd makes the worst case explicit.
Do not fail the build on one bad week. Alert on two consecutive failures, or on a drop against the previous run, not on an absolute number alone.
Synchronous calls stop at 5 minutes. Twenty checks finish well inside that; for hundreds of prompts, start the run asynchronously and poll it instead.
Different from rank tracking. This measures whether assistants name you, not where a page ranks in Google.

Give your AI agent search-demand and AI-answer tools: MCP and function calling, with real output

Wrenfield Data — Wed, 28 Oct 2026 03:59:21 +0000

Disclosure: I build the tools used here (Keyword Search Volume, AI Answer Scraper and AI Search Visibility Tracker on Apify). The sample output below comes from real runs I made on October 19 and 22, 2026; each tool function was run against those saved rows (no new calls), so you see exactly what your agent would read.

An agent with a browser tool can read any page. There are two questions it still cannot answer on its own:

How many people actually search for this? (demand, CPC)
What do ChatGPT, Perplexity and the other AI assistants tell buyers about it, and which sources do they cite?

This post wires both into an agent two ways: through MCP (no code) and as plain function-calling tools (about 60 lines of Python). It does not replace a page-content tool: for crawling and RAG ingestion, use something like Apify's Website Content Crawler or RAG Web Browser, Tavily, Exa or Firecrawl. These tools sit next to them.

Option 1: MCP, no code

Apify runs a hosted MCP server and exposes any Actor as a tool. Load only the tools you need, because fewer tools means better tool selection:

https://mcp.apify.com?tools=wrenfield-data/keyword-search-volume,wrenfield-data/ai-answer-scraper,wrenfield-data/ai-search-visibility-tracker

Claude Code: claude mcp add --transport http wrenfield "<the URL above>", then type /mcp and sign in to Apify.
Claude Desktop, Cursor, VS Code, ChatGPT apps: add the URL as a remote MCP server and sign in with Apify (OAuth). Clients without OAuth can send Authorization: Bearer <APIFY_TOKEN>.
Each tool shows the agent its input schema, so a prompt like this works as written:

Get US search volume for "crm software" and "email marketing tools". Then check whether Perplexity recommends HubSpot for "What is the best CRM for a small business?" and tell me which keyword to write about first.

Option 2: function tools in your own agent loop

If you run your own loop (OpenAI-style tool calls, Anthropic tool use, LangGraph, anything), each tool is one HTTP call to the Apify API. The helper below runs an Actor synchronously, returns its rows, and passes maxTotalChargeUsd so Apify stops the run at that spend, which is the guardrail you want when a model decides how often to call it.

"""Three agent tools backed by Wrenfield Data Actors on Apify. Each returns a short Markdown string an LLM can read.
Needs: pip install requests ; export APIFY_TOKEN=...   Every call is capped with maxTotalChargeUsd."""
import os
import requests

def run_actor(actor: str, payload: dict, max_usd: float = 0.50) -> list[dict]:
    """Run an Apify Actor synchronously and return its dataset rows. Aborts spending beyond max_usd."""
    r = requests.post(
        f"https://api.apify.com/v2/acts/{actor.replace('/', '~')}/run-sync-get-dataset-items",
        params={"maxTotalChargeUsd": max_usd},
        headers={"Authorization": f"Bearer {os.environ['APIFY_TOKEN']}"},
        json=payload, timeout=300)
    r.raise_for_status()
    return r.json()

def keyword_demand(keywords: list[str], country: str = "United States") -> str:
    """Monthly Google search volume and CPC per keyword."""
    rows = run_actor("wrenfield-data/keyword-search-volume", {"keywords": keywords, "location": country}, max_usd=0.50)
    out = ["| keyword | searches / month | CPC (USD) | competition |", "|---|---|---|---|"]
    for r in rows:
        if r.get("type") != "keyword":
            continue
        vol = f"{r['search_volume']:,}" if r.get("found") and r.get("search_volume") is not None else "no data"
        cpc = f"{r['cpc']:.2f}" if r.get("cpc") is not None else "-"
        out.append(f"| {r['keyword']} | {vol} | {cpc} | {r.get('competition') or '-'} |")
    return "\n".join(out)

def ai_answer(prompt: str, engines: tuple[str, ...] = ("perplexity", "chatgpt")) -> str:
    """What AI engines answer to a prompt, with the sources they cite."""
    rows = run_actor("wrenfield-data/ai-answer-scraper", {"prompts": [prompt], "engines": list(engines)}, max_usd=0.25)
    out = []
    for r in rows:
        if r.get("status") != "ok":
            out.append(f"## {r.get('engine_name')}: no answer ({r.get('note')})")
            continue
        src = ", ".join(r.get("cited_domains", [])[:5]) or "none"
        out.append(f"## {r['engine_name']}\n{r['answer_markdown'][:1500]}\n\nCited domains: {src}")
    return "\n\n".join(out)

def brand_check(brand: str, domain: str, prompts: list[str], competitors: list[str] | None = None,
                engines: tuple[str, ...] = ("perplexity", "chatgpt")) -> str:
    """Does each engine name the brand for each prompt, in what position, and which competitors does it name instead?"""
    rows = run_actor("wrenfield-data/ai-search-visibility-tracker",
                     {"brands": [brand], "domains": [domain], "prompts": prompts, "engines": list(engines),
                      "competitors": competitors or []},   # e.g. ["Salesforce | salesforce.com", "Pipedrive | pipedrive.com"]
                     max_usd=1.00)
    out = []
    for r in rows:
        if r.get("type") != "check":
            continue
        if r.get("status") != "ok":
            out.append(f"- {r['engine_name']} | {r['prompt']}: no answer")
            continue
        said = f"named (position {r['brand_position']})" if r.get("brand_mentioned") else "not named"
        rivals = ", ".join(r.get("competitors_mentioned") or r.get("other_brands_mentioned") or []) or "no competitors named"
        out.append(f"- {r['engine_name']} | {r['prompt']}: {brand} {said}; others: {rivals}")
    return "\n".join(out)

Two design choices that matter for agents:

Return Markdown or short text, not raw rows. A 31-field JSON row costs tokens and the model ignores most of it. Each function keeps the fields the model needs.
Cap every call. The caps above are $0.50, $0.25 and $1.00 per call. At current Free-plan prices, keyword_demand costs $0.004 per keyword, ai_answer $0.015 per answer, and brand_check $0.04 per prompt per engine (the tracker price is scheduled to change to $0.06 on November 2, 2026; check the Actor page).

What the agent reads

keyword_demand(["crm software", "email marketing tools"]) (real rows, Google Ads live source, run on Oct 22, 2026):

| keyword | searches / month | CPC (USD) | competition |
|---|---|---|---|
| crm software | 201,000 | 37.13 | LOW |
| email marketing tools | 4,400 | 101.75 | LOW |

ai_answer("What is the best CRM for a small business?", ("perplexity",)) (real Perplexity answer from Oct 19, 2026, cut in this post; the function itself returns up to 1,500 characters):

## Perplexity
**For most small businesses, HubSpot CRM is the best starting point**: it offers a free entry point, contact management, deal pipelines, and marketing/service features in one ecosystem.[4][6] Choose **Zoho CRM** instead if keeping costs low and gaining broad functionality matter most; choose **Pipedrive** if your main priority is a simple, sales-focused pipeline.[2][4]

| Best for | CRM | Why choose it |
|---|---|---|
| Best overall starting point | **HubSpot CRM** | Easy to adopt, with free tools and sales, marketing, and service capabilities.[4][6] |
[... 4 more rows and a short recommendation list cut for this post ...]

Cited domains: salesforce.com, pcmag.com, techradar.com, wise.com, microsoft.com

brand_check("HubSpot", "hubspot.com", ["What is the best CRM for a small business?"], ["Salesforce | salesforce.com", "Pipedrive | pipedrive.com"]) (real run, Oct 22, 2026):

- Perplexity | What is the best CRM for a small business?: HubSpot named (position 1); others: Salesforce, Pipedrive
- ChatGPT | What is the best CRM for a small business?: HubSpot named (position 1); others: Salesforce, Pipedrive

The brand check returns booleans and positions, not prose, so the agent can branch on brand_mentioned instead of reading an essay.

Putting it together in one prompt

You are a content strategist. For each candidate topic, call keyword_demand. For the best one, call ai_answer and brand_check and write a three-line brief: the demand, who the AI assistants recommend today, and one source they cite that we should try to get listed on.

The loop is: demand first (cheap), then AI answers only for the topic that earns it (more expensive per call). That ordering keeps the cost per brief at well under a dollar.

Limits, so you can trust what you see

AI answers are samples. The same prompt gives a different answer next time and differs between engines. One answer is an anecdote; ten prompts across two engines, tracked weekly, is a signal.
The volume sample is a paid-plan source. Free Apify plan runs of Keyword Search Volume read a keyword database and are capped at 10 keywords per run.
Perplexity and ChatGPT agree here (HubSpot first in both), but that is one question in one category, not a general finding.
Not a replacement for page tools. If your agent needs the text of a page, use a crawler or a search API that returns page content.

Competitor keyword research without Ahrefs or Semrush: exact search volume first (Python + n8n)

Wrenfield Data — Tue, 27 Oct 2026 00:18:46 +0000

Disclosure: I built the five Apify Actors used here: Keyword Search Volume, SEO Toolkit, Competitor Keywords, Keyword Difficulty Checker and People Also Ask Scraper. All data below is from real runs on October 18, 2026 (US). I'm not affiliated with Ahrefs, Semrush or the example competitor.

Ahrefs and Semrush are excellent. But if you do competitor research a few times a month, or you want the data inside a script or an n8n workflow, a $100–$500/month seat is a lot. This post runs a complete competitor analysis with five pay-per-use calls and ends with a concrete content plan. The step that does the most work is the boring one: exact Google search volume and CPC for every candidate keyword, so you rank opportunities on real demand instead of estimates.

The example: a new site that wants to compete with upliftdesk.com, a standing desk brand.

The workflow

Domain overview: how big is the competitor?
Competitor keywords: what does it rank for, and which URL earns the traffic?
Exact search volume + CPC: how much demand, and how much is it worth to advertisers?
Keyword difficulty + intent: which of those keywords can a smaller site win?
People Also Ask: what should the article answer?

Setup

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

def run(actor, inp, cap=1.0):
    r = client.actor(actor).call(run_input=inp, max_total_charge_usd=cap)
    assert r.status == "SUCCEEDED", r.status
    return list(client.dataset(r.default_dataset_id).iterate_items())

Step 1: domain overview

ov = run("wrenfield-data/seo-toolkit", {"tool": "domain_overview", "targets": ["upliftdesk.com"],
                              "location": "United States"})[0]

Result (5 seconds):

Metric	upliftdesk.com
Organic keywords (US)	15,414
Estimated monthly organic traffic	74,939
Estimated traffic value / month	$228,543
Keywords in top 3 / top 10	2,628 / 6,536
Referring domains / backlinks	4,221 / 44,647
Spam score	4

A strong, well-linked competitor. Going after its head terms head-on is a losing plan, so we need to be selective.

Step 2: what it ranks for

kws = run("wrenfield-data/competitor-keywords", {"domains": ["upliftdesk.com"], "location": "United States",
                                       "maxKeywordsPerDomain": 25, "sortBy": "traffic"})

Top non-branded rows (4 seconds):

Keyword	Position	Volume	Est. traffic	Ranking URL
standing desk	5	135,000	3,532	/2-leg-standing-desk/
adjustable desk	1	22,200	2,035	/standing-desks/
stand up desk	1	18,100	1,401	/standing-desks/
electric standing desk	2	27,100	1,379	/standing-desks/
ergonomic office chair	8	165,000	912	/ergonomic-chairs/
monitor arm	2	22,200	864	/desk-accessories/monitor-arms/
height adjustable desk	2	12,100	676	/standing-desks/
kneeling chair	2	14,800	578	/ergonomic-kneeling-chair-by-uplift-desk/

Each row also has keyword_difficulty, search_intent, serp_features, previous_position and position_change, so you can sort by "keywords they're losing" too. Notice how much traffic one category page (/standing-desks/) earns.

Step 3: exact volume and CPC

Competitor tools estimate volume. For the shortlist you are going to plan content around, pull the numbers Google Ads itself reports:

vol = run("wrenfield-data/keyword-search-volume", {"keywords": [
    "standing desk", "best standing desk", "standing desk converter", "standing desk benefits",
    "l shaped standing desk", "standing desk mat", "walking pad"], "location": "United States"})

Keyword	Avg. monthly searches	CPC	Competition
walking pad	246,000	$1.24	HIGH
standing desk	135,000	$5.16	HIGH
standing desk converter	18,100	$2.24	HIGH
l shaped standing desk	12,100	$5.47	HIGH
best standing desk	8,100	$7.28	HIGH
standing desk benefits	2,900	$0.73	LOW
standing desk mat	1,900	$3.94	HIGH

Each row also carries top-of-page bids and a 12-month monthly_searches history. Two things already change the plan: "walking pad" has almost twice the demand of "standing desk" at a quarter of the CPC, and "best standing desk" has the highest CPC on the list ($7.28), which says comparison content on it monetizes. This costs $4 per 1,000 keywords, and keywords Google has no data for are free. (Full walkthrough: How to get exact Google search volume without a Google Ads account.)

Step 4: difficulty and intent

kd = run("wrenfield-data/keyword-difficulty-checker", {"keywords": [
    "standing desk", "best standing desk", "standing desk converter", "standing desk benefits",
    "l shaped standing desk", "standing desk mat", "walking pad", "standing desk for small spaces"],
    "location": "United States", "includeSearchIntent": True})

Keyword	KD (0–100)	Intent	Volume*
standing desk	38	transactional	135,000
best standing desk	36	commercial	8,100
standing desk converter	7	transactional	18,100
standing desk benefits	31	commercial	2,900
l shaped standing desk	10	transactional	12,100
standing desk mat	7	transactional	1,900
walking pad	53	informational	246,000
standing desk for small spaces	10	commercial	—

*Volume from Step 3 (Keyword Search Volume, Google Ads data).

"standing desk converter" (KD 7, 18,100/mo, $2.24 CPC, transactional) and "l shaped standing desk" (KD 10, 12,100/mo, $5.47 CPC) are the standouts: real buyer demand that advertisers pay for, and low difficulty.

Step 5: People Also Ask

paa = run("wrenfield-data/people-also-ask-scraper", {"keywords": ["standing desk benefits"],
                                           "location": "United States", "clickDepth": 1})

Questions Google showed (6 seconds):

Is standing for 7 hours a day unhealthy?
What is the 20/8-2 rule for standing desks?
What's the ideal height for a standing desk?
What are the downsides of using a standing desk?
- ↳ Is a standing desk actually healthier?
- ↳ How long should you stand at a standing desk per day?

These become the H2s of the explainer article.

The plan the data produces

Buyer guide: standing desk converters (KD 7, 18.1K/mo).
Buyer guide: L-shaped standing desks (KD 10, 12.1K/mo).
Explainer: standing desk benefits, structured around the PAA questions, linking to both guides.
Skip "standing desk" (KD 38) for now. Revisit once the site has links.

Five API calls, under a minute of total run time.

Same thing in n8n

Use the official Apify node, operation Run an Actor and get dataset, once per step: wrenfield-data/competitor-keywords → wrenfield-data/keyword-search-volume (exact volume + CPC for the whole list; keywords without data are free) → wrenfield-data/keyword-difficulty-checker → Filter (keyword_difficulty < 20) → wrenfield-data/people-also-ask-scraper on the survivors → Google Sheets. Paste each JSON input above into the node's input field.

One API instead of four

The SEO Toolkit exposes eight reports behind one tool parameter: domain_overview, ranked_keywords, competitors, top_pages, backlinks, referring_domains, keyword_overview, serp. That makes it a single tool for AI agents via the Apify MCP server.

{"tool": "ranked_keywords", "targets": ["upliftdesk.com"], "location": "United States", "maxResults": 1000}

Cost and caveats

Everything is pay per result or per request, with no subscription; each Actor's Pricing tab lists the current prices and paid Apify plans get volume discounts. Traffic and traffic value are estimates (position × volume × CTR model), and every SEO data vendor's numbers differ. Use them to rank opportunities, not to forecast revenue.

How to get exact Google search volume without a Google Ads account

Wrenfield Data — Tue, 20 Oct 2026 15:04:04 +0000

Disclosure: I built Keyword Search Volume, the Apify Actor used in this tutorial. All numbers below come from real runs on October 18, 2026 (US, English).

Open Google Keyword Planner without an active ad campaign and the "Avg. monthly searches" column shows ranges: 1K–10K, 10K–100K. A keyword searched 1,300 times a month and one searched 9,400 times land in the same bucket. You can't plan a content calendar on that.

Google shows exact averages to accounts with ad spend. The underlying data is also available through the Google Ads API, and that's what this tutorial uses, without you needing a Google Ads account, a developer token or a credit card on Google's side.

What you'll have after 5 minutes: a spreadsheet with exact monthly search volume, CPC, competition, top-of-page bids and 12 months of history for every keyword on your list, plus keyword ideas from a seed.

Prefer video? The same walkthrough is on YouTube: Exact Google search volume without a Google Ads account (video).

What you need

A free Apify account. The free plan includes $5 of platform credit per month and no card is required. (Free-plan runs of this Actor use a monthly-refreshed keyword database and are capped at 10 keywords / 10 ideas per run; a paid plan removes the caps.)
A list of keywords. That's it. No code needed, but there's an API section at the end.

Step 1: Paste your keywords

Open Keyword Search Volume and click Try for free. In the input form:

Keywords: one per line. I used eight keywords for a hypothetical home-office blog.
Location: United States (also accepts GB, a Google Ads location code like 2840, or a city such as California,United States).
Language: English.
What to get: Search volume.

The exact input of my run:

{
  "keywords": ["standing desk", "standing desk converter", "best standing desk",
               "electric standing desk", "standing desk benefits",
               "l shaped standing desk", "standing desk mat", "walking pad"],
  "location": "United States",
  "language": "English",
  "mode": "search_volume",
  "includeMonthlySearches": true
}

Click Start. My run finished in 25 seconds.

Step 2: Read the results

Keyword	Avg. monthly searches	CPC	Competition
walking pad	246,000	$1.24	HIGH
standing desk	135,000	$5.16	HIGH
electric standing desk	22,200	$3.27	HIGH
standing desk converter	18,100	$2.24	HIGH
l shaped standing desk	12,100	$5.47	HIGH
best standing desk	8,100	$7.28	HIGH
standing desk benefits	2,900	$0.73	LOW
standing desk mat	1,900	$3.94	HIGH

Three things jump out that Keyword Planner's ranges would hide:

"walking pad" is almost twice as big as "standing desk" (246K vs 135K), and its CPC is a quarter of the price. In range mode both show as "100K–1M".
"best standing desk" has the highest CPC ($7.28) on the list. Advertisers pay most for comparison intent, which is a strong hint that a review article on that term monetizes well.
"standing desk benefits" is the only LOW-competition keyword. Small (2,900/mo) but informational and cheap to rank for.

Note: Google's "competition" column is about ad competition, not how hard it is to rank organically. For organic difficulty, see the next part of this series (keyword difficulty).

Step 3: Check seasonality

Every row includes monthly_searches, the month-by-month volume for the last 12 months (or up to 4 years with dateFrom/dateTo). Plot it before you schedule content: both "standing desk" and "electric standing desk" were 18–33% down month-over-month in this run, while "standing desk benefits" was up 24%. Publish a buyer guide ahead of the seasonal peak, not after it.

Step 4: Find new keywords from one seed

Switch What to get to Keyword ideas, enter a single seed (standing desk), set Max keyword ideas to 30 and Minimum search volume for ideas to 100. My run took 9 seconds and returned 30 ideas. A sample:

Keyword idea	Monthly searches	CPC
stand up desk	18,100	$5.59
sit stand desk	18,100	$6.01
adjustable desk	18,100	$3.35
adjustable standing desk	14,800	$3.83
laptop stand for desk	12,100	$1.00
standing desk with drawers	8,100	$2.81
small standing desk	4,400	$2.73
corner standing desk	2,900	$3.70

Ideas also include brand terms (FlexiSpot, Jarvis, Vari, Uplift). Those are useful if you write comparisons, and easy to filter out if you don't.

Step 5: Export, schedule or call it as an API

Download as CSV/Excel/JSON from the run page. To track demand monthly, save the input as a task and add a schedule. Or call it as a search volume API:

curl -X POST \
  "https://api.apify.com/v2/acts/wrenfield-data~keyword-search-volume/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["standing desk", "walking pad"], "location": "United States"}'

Python:

from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("wrenfield-data/keyword-search-volume").call(
    run_input={"keywords": ["standing desk", "walking pad"], "location": "United States"},
    max_total_charge_usd=1.0,   # hard cap for this run
)
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["keyword"], row["search_volume"], row["cpc"])

It also works from Make, Zapier, n8n (official Apify node) and AI agents via the Apify MCP server.

What it costs

Pay per event: $4 per 1,000 keyword results plus a small fee per Google Ads request (up to 1,000 keywords per request). Keywords with no data are free, and paid Apify plans get volume discounts automatically. The Actor's Pricing tab has the current numbers. Set Maximum cost per run if you want a hard ceiling.

Caveats (read before you trust any volume number)

Google groups close variants ("standing desk" / "standing desks") and reports the same number for both. Don't add them up.
Google rounds into buckets (8,100, 12,100, 18,100…). Treat volumes as directional; compare keywords to each other rather than reading them as exact traffic.
CPC is the advertiser average, not what you'll earn per visitor.

Next: which of these keywords can you actually win?

Volume tells you what's worth having; it doesn't tell you what a young site can rank for. Two companion Actors take the same list one step further:

Bulk Keyword Difficulty Checker: keyword difficulty (0–100) and search intent for each keyword, $5 per 1,000 keywords. On this list, "standing desk converter" scored KD 7 and "l shaped standing desk" KD 10 in an October 18 run, versus 38 for "standing desk": 18,100 and 12,100 searches a month that a small site can realistically go after.
Competitor Keywords: every keyword a competitor's domain ranks for, with position and estimated traffic, $2 per 1,000 keywords plus $0.03 per domain. Feed the results back into Keyword Search Volume when you need exact volume and CPC for the whole list.

Next in this series: competitor keyword research without an Ahrefs subscription (exact volume first, then difficulty), and tracking which brands ChatGPT recommends.