You may have an idea: building an AI resume builder, a PDF tool site, a small SaaS product, a content site, an affiliate site, a niche directory, or even a local service website. The first question is simple: is this direction actually worth building?

Many people judge by instinct: this niche seems popular, there seem to be many existing sites, and users probably need it. But before you start building, a more reliable approach is to look at search results. Search results already contain user demand, page types, content formats, and commercial signals.

This article walks through a complete workflow: starting from a project idea, using the TalorData SERP API to collect real search results, turning those results into tables, and then deciding whether the direction has an opportunity.

We will use AI Resume Builder as the example. The same method can also be applied to tool sites, SaaS products, content sites, affiliate sites, directories, and local service websites.

What You Will Get at the End

By following this article, you will produce three tables:

• Keyword candidate table: turn a project idea into a set of searchable keywords.
• SERP result table: use the SERP API to check each keyword and collect ranking pages, PAA, ads, domains, and other useful signals.
• Opportunity decision table: use simple rules to decide which keywords are worth targeting and which ones should be postponed or avoided.

At the end, you should be able to answer three questions:

• Is there real search demand for this direction?
• Which sites are already ranking in search results?
• If I build this now, which keyword or feature should I start with?

Step 1: Turn the Idea into Searchable Keywords

Let's start with a concrete idea: I want to build an AI Resume Builder.

This idea is still too broad. You cannot judge the whole project with only one phrase, because a project usually contains many different user needs. Some users want a free tool. Some want an online resume builder. Some want a cover letter generator. Some only need a resume summary generator.

So the first step is not writing code or calling an API. The first step is turning the idea into search queries that real users might type into Google.

Step 2: Where the Keywords Come From

Keywords should not be guessed randomly. You can get the first batch from several sources.

1. Break Down the Core Features

For an AI Resume Builder, you can start with the core features:

• Resume generation: ai resume builder
• Online resume tool: resume builder online
• Free resume tool: free resume builder
• Resume summary generation: resume summary generator
• Cover letter generation: cover letter generator
• Resume bullet point generation: resume bullet point generator

2. Expand with User Modifiers

When users search for tools, they often add modifiers such as:

• best, for example best resume builder
• free, for example free resume builder
• online, for example resume builder online
• generator, for example resume summary generator
• template, for example resume template
• alternative, for example zety alternative

3. Add Keywords from Search Suggestions and Existing Pages

You can also expand keywords from Google autocomplete, People Also Ask, existing page titles, and discussions on Reddit or Quora.

If you do not know where to start, you can use ChatGPT to generate an initial keyword list, then use a SERP API to verify whether those keywords actually have search results and ranking pages.

Step 3: Create keywords.csv

Put the keywords into a CSV file. Keep the first version simple, with only one column: keyword.

keyword
ai resume builder
resume builder online
free resume builder
resume summary generator
cover letter generator
resume bullet point generator
ai cover letter generator
best resume builder

If you are testing a different project, just replace this column. For example:

• PDF tool site: pdf compressor online, merge pdf online, pdf to word converter
• SaaS: email verification API, invoice software, booking software
• Content site: best dog food for puppies, how to train a puppy
• Local service site: plumber near me, emergency dentist near me

Step 4: Query Keywords with the TalorData SERP API

Next, send one SERP API request for each keyword. You can register a TalorData account and get an API key with free credits from the official website.

Keep in mind that API requests consume quota. In general, one keyword means at least one request. If you prepare 20 keywords, the test will use around 20 requests. Before expanding the test, start with 5-10 keywords to make sure the workflow works.

The basic TalorData request format looks like this:

curl -X POST 'https://serpapi.talordata.net/serp/v1/request' \
  -H 'Authorization: Bearer YOUR_TALORDATA_API_KEY' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'engine=google' \
  -d 'q=ai resume builder' \
  -d 'json=2'

This request returns Google SERP data for the keyword. For decision-making, we mainly care about these fields:

• organic results: natural search results, used to see who ranks at the top.
• People Also Ask: user questions, used to identify content opportunities.
• ads: advertising results, if available, used to estimate commercial value.
• titles and URLs: used to understand page types.
• domains: used to identify and count the sites that appear in search results.

Step 5: Run the Script and Generate the Result Table

The script reads keywords.csv, queries the TalorData SERP API, and outputs two files:

• serp_opportunities.csv: the analysis table used for judging opportunities.
• serp_raw_records.jsonl: the raw crawl records, useful for checking how each conclusion was produced.

In the main article, we only show the key part of the code:

TALORDATA_API_KEY = "YOUR_TALORDATA_API_KEY_HERE"
ENDPOINT = "https://serpapi.talordata.net/serp/v1/request"

headers = {
    "Authorization": f"Bearer {TALORDATA_API_KEY}",
    "Content-Type": "application/x-www-form-urlencoded",
    "User-Agent": "curl/8.0.0",
}

data = {
    "engine": "google",
    "q": keyword,
    "json": "2",
}

response = requests.post(ENDPOINT, headers=headers, data=data, timeout=60)
response.raise_for_status()
result = response.json()

This is the part that sends a keyword to TalorData and receives the SERP response. The full script is included at the end of the article.

Step 6: Look at the Result Table Before Judging the Opportunity

The script will produce a table similar to this:

This table is your first project opportunity map. It shows demand strength, ranking-site patterns, and commercial signals behind each keyword.

Step 7: How to Decide Whether a Signal Is Strong or Weak

When judging opportunities, avoid vague words like "many", "few", "strong", or "weak". Use simple rules instead.

Here, major sites mean strong brands, platforms, or high-authority websites, such as Canva, LinkedIn, Indeed, HubSpot, Forbes, and Wikipedia.

Small sites usually mean niche tool sites, small SaaS products, personal blogs, niche content sites, or emerging product sites.

You should also keep clear "give up" signals. If almost every keyword has a Top 10 dominated by major sites, very few PAA questions, no ads, and no small sites ranking, the direction may have weak demand or may already be heavily monopolized. In that case, do not force the conclusion that it is still worth doing. A better move is to switch to a more specific keyword or choose another direction.

Step 8: Turn the Result into a Conclusion

Now let's go back to the AI Resume Builder example. Based on the sample results, we can make these judgments:

• ai resume builder: strong demand, but also strong competition. It is not a good first breakthrough keyword.
• free resume builder: high traffic and commercial value, but many major brands compete for it.
• resume summary generator: more specific, with many PAA questions, suitable as an early entry point.
• cover letter generator: clear demand, suitable as a second feature page.

So the direction is not "not worth doing". The real conclusion is: do not start by attacking the hardest core keyword. A more practical starting point is to build specific feature pages first, then expand toward the main tool page.

Step 9: Create Your Opportunity Decision Table

Finally, convert each keyword into a clear decision.

The goal is not to produce an absolutely correct answer. The goal is to decide where to put resources first: which pages to build now, which keywords to postpone, and which directions are not worth continuing.

Optional: Turn the Rules into a Simple Score

If you want more automation, you can turn the rules from Step 7 into a simple scoring function. This lets the script output an initial score for each keyword.

def score_keyword(paa_count, ads_present, big_site_count, small_site_count):
    score = 0

    if paa_count >= 4:
        score += 2
    elif paa_count >= 1:
        score += 1

    if ads_present:
        score += 2

    if small_site_count >= 2:
        score += 2

    if big_site_count >= 4:
        score -= 2

    if score >= 4:
        return "High"
    if score >= 2:
        return "Medium"
    return "Low"

This score should not replace human judgment, but it can help you quickly identify which keywords deserve attention first.

Step 10: Apply the Method to Your Own Project

This method can be reused across many project types. You only need to replace the keywords.

The general workflow is:

Project idea -> Find keywords -> Query with TalorData SERP API -> Get result table -> Judge opportunity by rules -> Decide whether to build and where to start

Conclusion

A project direction should not be judged only by instinct. You need to look at real search results to understand demand, commercial value, existing ranking sites, and possible entry points.

The value of a SERP API is that it turns Google search results into data you can analyze in batches.

For a new project, the best direction is not always the most popular one. A better direction is one with search demand, commercial value, room for content or feature expansion, and a realistic entry point for a new site.

If you already have an idea, start with 5-10 keywords and run this workflow once. You will have a much clearer view of whether the direction is worth building and where your first step should be.

Full Python script

# -*- coding: utf-8 -*-
import csv
import json
from datetime import datetime
from pathlib import Path
from urllib.parse import urlparse

import requests


ROOT = Path(__file__).resolve().parent
ENDPOINT = "https://serpapi.talordata.net/serp/v1/request"
TALORDATA_API_KEY = "YOUR_TALORDATA_API_KEY_HERE"
SERP_PAGE = ""
SERP_NUM = ""


def get_domain(url):
    try:
        return urlparse(url).netloc.replace("www.", "")
    except Exception:
        return ""


def normalize_serp_response(result):
    serp_json = result.get("data", {}).get("json", result)
    if isinstance(serp_json, str):
        return json.loads(serp_json)
    return serp_json


def find_first(data, keys):
    if isinstance(data, dict):
        for key in keys:
            if key in data:
                return data[key]
        for value in data.values():
            found = find_first(value, keys)
            if found is not None:
                return found
    elif isinstance(data, list):
        for item in data:
            found = find_first(item, keys)
            if found is not None:
                return found
    return None


def as_list(value):
    if isinstance(value, list):
        return value
    if isinstance(value, dict):
        return list(value.values())
    return []


def count_any(data, keys):
    value = find_first(data, keys)
    return len(as_list(value))


def fetch_serp(keyword, api_key):
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/x-www-form-urlencoded",
        "User-Agent": "curl/8.0.0",
        "Accept": "application/json, text/plain, */*",
    }
    data = {
        "engine": "google",
        "q": keyword,
        "json": "2",
    }
    page = SERP_PAGE.strip()
    num = SERP_NUM.strip()
    if page:
        data["page"] = page
    if num:
        data["num"] = num
    response = requests.post(ENDPOINT, headers=headers, data=data, timeout=60)
    response.raise_for_status()
    return normalize_serp_response(response.json())


def classify_opportunity(paa_count, ads_present, top_domains):
    big_brand_markers = (
        "linkedin.com",
        "indeed.com",
        "canva.com",
        "wikipedia.org",
        "forbes.com",
        "hubspot.com",
    )
    big_site_count = sum(
        1 for domain in top_domains if any(marker in domain for marker in big_brand_markers)
    )
    if paa_count >= 4 and big_site_count <= 2:
        return "High", "Many PAA questions; top results aren’t fully dominated by major sites."
    if ads_present and paa_count >= 3:
        return "Medium", "There is commercial value and some content opportunity."
    if big_site_count >= 4:
        return "Low", "Many major sites in top results; difficult for new sites to enter."
    return "Medium", "Some opportunity; assess further with competitor pages."


def analyze_keyword(keyword, api_key):
    serp = fetch_serp(keyword, api_key)
    organic_results = as_list(
        find_first(serp, ("organic_results", "organic", "organicResults"))
    )
    paa = as_list(
        find_first(serp, ("people_also_ask", "related_questions", "peopleAlsoAsk"))
    )
    ads = as_list(
        find_first(
            serp,
            (
                "ads",
                "paid_results",
                "top_ads",
                "bottom_ads",
                "sponsored_results",
                "sponsored",
                "ad_results",
                "text_ads",
                "shopping_ads",
            ),
        )
    )
    ads_count = len(ads)
    if ads_count == 0:
        ads_count = (
            count_any(serp, ("top_ads",))
            + count_any(serp, ("bottom_ads",))
            + count_any(serp, ("sponsored_results",))
            + count_any(serp, ("sponsored",))
            + count_any(serp, ("ad_results",))
            + count_any(serp, ("text_ads",))
            + count_any(serp, ("shopping_ads",))
        )

    top_domains = []
    for item in organic_results[:10]:
        if not isinstance(item, dict):
            continue
        link = item.get("link") or item.get("url") or item.get("href") or ""
        domain = get_domain(link)
        if domain:
            top_domains.append(domain)

    opportunity_level, recommendation = classify_opportunity(
        len(paa), ads_count > 0, top_domains
    )

    analysis_row = {
        "keyword": keyword,
        "organic_count": len(organic_results),
        "paa_count": len(paa),
        "ads_count": ads_count,
        "ads_present": str(ads_count > 0).lower(),
        "top_domains": ", ".join(top_domains[:5]),
        "opportunity_level": opportunity_level,
        "recommendation": recommendation,
    }
    raw_record = {
        "keyword": keyword,
        "organic_results": organic_results,
        "paa": paa,
        "ads": ads,
        "top_domains": top_domains,
        "full_response": serp,
    }
    return analysis_row, raw_record


def main():
    api_key = TALORDATA_API_KEY.strip()
    if not api_key or api_key == "YOUR_TALORDATA_API_KEY_HERE":
        raise SystemExit(
            "Missing API key. Open analyze_serp_opportunities.py and set TALORDATA_API_KEY."
        )

    keyword_path = ROOT / "keywords.csv"
    output_path = ROOT / "serp_opportunities.csv"
    raw_output_path = ROOT / "serp_raw_records.jsonl"

    with keyword_path.open("r", encoding="utf-8-sig", newline="") as f:
        keywords = [row["keyword"].strip() for row in csv.DictReader(f) if row["keyword"].strip()]

    rows = []
    raw_records = []
    for keyword in keywords:
        print(f"Analyzing: {keyword}")
        row, raw_record = analyze_keyword(keyword, api_key)
        rows.append(row)
        raw_records.append(raw_record)

    fieldnames = [
        "keyword",
        "organic_count",
        "paa_count",
        "ads_count",
        "ads_present",
        "top_domains",
        "opportunity_level",
        "recommendation",
    ]
    try:
        handle = output_path.open("w", encoding="utf-8-sig", newline="")
    except PermissionError:
        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
        output_path = ROOT / f"serp_opportunities_{stamp}.csv"
        handle = output_path.open("w", encoding="utf-8-sig", newline="")
        print(f"serp_opportunities.csv is locked. Writing to {output_path.name} instead.")

    with handle as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)

    try:
        raw_handle = raw_output_path.open("w", encoding="utf-8")
    except PermissionError:
        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
        raw_output_path = ROOT / f"serp_raw_records_{stamp}.jsonl"
        raw_handle = raw_output_path.open("w", encoding="utf-8")
        print(f"serp_raw_records.jsonl is locked. Writing to {raw_output_path.name} instead.")

    with raw_handle as f:
        for record in raw_records:
            f.write(json.dumps(record, ensure_ascii=False) + "\n")

    print(f"Done: {output_path}")
    print(f"Raw records: {raw_output_path}")


if __name__ == "__main__":
    main()