Turn SERP Results into a Simple Market Map by Domain Category

A search result page can tell you more than rankings.

For a market research workflow, the useful question is often not just:

Who ranks first?

It is:

What kinds of players show up when buyers search this topic?

For example, a SERP for a commercial keyword may contain:

• product homepages
• pricing pages
• review sites
• comparison blogs
• directories
• documentation pages
• marketplaces
• community discussions
• analyst or media articles

That mix is a rough market map.

This post shows a simple way to turn SERP results into a categorized market map. A SERP API such as TalorData SERP API can collect the result data; your code can classify domains and page types for analysis.

What we want to build

Input:

• a list of keywords
• a target location
• top organic results for each keyword

Output:

• domains appearing across the keyword set
• category for each domain
• page type for each ranking URL
• count of appearances
• highest observed position
• example queries where the domain appeared

This is not a full competitive intelligence platform. It is a practical first pass for understanding the shape of a market.

Example categories

Start with a small category set:

• vendor
• review_site
• directory
• marketplace
• media
• docs_or_education
• community
• unknown

You can make the taxonomy more specific later. The first version should be easy to review.

Example page types

For page types, use:

• homepage
• pricing
• comparison
• review
• guide
• documentation
• community_thread
• category_page
• unknown

Domain category answers "who is this?"

Page type answers "what kind of page is ranking?"

Both are useful.

A normalized SERP result

Keep the SERP API response separate from your analysis model. Normalize the fields you need:

{
  "query": "serp api for seo monitoring",
  "location": "United States",
  "captured_at": "2026-07-20T09:00:00Z",
  "results": [
    {
      "position": 1,
      "title": "Example SERP API Platform",
      "url": "https://example.com/serp-api",
      "snippet": "Collect search result data for monitoring workflows."
    }
  ]
}

The example is intentionally generic. Replace the field paths with the response schema from your SERP provider.

Extract the domain

from urllib.parse import urlparse


def clean_domain(url: str) -> str:
    host = urlparse(url).netloc.lower()
    if host.startswith("www."):
        host = host[4:]
    return host

Classify page type with transparent rules

def classify_page_type(url: str, title: str) -> str:
    text = f"{url} {title}".lower()

    if "/pricing" in text or "pricing" in title.lower():
        return "pricing"
    if "compare" in text or "alternative" in text:
        return "comparison"
    if "review" in text or "ratings" in text:
        return "review"
    if "/docs" in text or "documentation" in text:
        return "documentation"
    if "how to" in text or "guide" in text or "tutorial" in text:
        return "guide"
    if "forum" in text or "community" in text or "reddit" in text:
        return "community_thread"
    if urlparse(url).path in ["", "/"]:
        return "homepage"

    return "unknown"

The goal is not perfect classification. The goal is a reviewable first pass.

Classify domain category

Some domain categories need a known list. For example:

REVIEW_DOMAINS = {"g2.com", "capterra.com", "trustpilot.com"}
COMMUNITY_DOMAINS = {"reddit.com", "stackoverflow.com", "news.ycombinator.com"}
MEDIA_DOMAINS = {"techcrunch.com", "forbes.com", "wired.com"}


def classify_domain(domain: str, page_type: str) -> str:
    if domain in REVIEW_DOMAINS:
        return "review_site"
    if domain in COMMUNITY_DOMAINS:
        return "community"
    if domain in MEDIA_DOMAINS:
        return "media"
    if page_type == "documentation":
        return "docs_or_education"
    if page_type in {"pricing", "homepage"}:
        return "vendor"
    return "unknown"

You can add a manual override file later:

{
  "example.com": "vendor",
  "example-directory.com": "directory"
}

Manual overrides are useful because domain classification is often market-specific.

Build the market map

from collections import defaultdict


def build_market_map(serps: list[dict]) -> list[dict]:
    rows = {}

    for serp in serps:
        query = serp["query"]

        for result in serp["results"][:10]:
            url = result.get("url", "")
            title = result.get("title", "")
            position = result.get("position", 99)

            domain = clean_domain(url)
            page_type = classify_page_type(url, title)
            domain_category = classify_domain(domain, page_type)

            if domain not in rows:
                rows[domain] = {
                    "domain": domain,
                    "category": domain_category,
                    "appearances": 0,
                    "best_position": position,
                    "page_types": defaultdict(int),
                    "example_queries": set(),
                }

            row = rows[domain]
            row["appearances"] += 1
            row["best_position"] = min(row["best_position"], position)
            row["page_types"][page_type] += 1
            row["example_queries"].add(query)

    output = []
    for row in rows.values():
        output.append({
            "domain": row["domain"],
            "category": row["category"],
            "appearances": row["appearances"],
            "best_position": row["best_position"],
            "page_types": dict(row["page_types"]),
            "example_queries": sorted(row["example_queries"])[:5],
        })

    return sorted(output, key=lambda item: (-item["appearances"], item["best_position"]))

What to inspect first

Once the map is built, look for questions like:

• Are vendor domains dominating the SERP?
• Are review and directory sites acting as gatekeepers?
• Are community discussions ranking for commercial queries?
• Are documentation pages visible for developer keywords?
• Are the same domains appearing across many adjacent keywords?
• Are top pages mostly category pages, comparison pages, or educational guides?

These questions are more useful than a plain rank export.

Store evidence

For each classified row, keep enough evidence for review:

• domain
• category
• page type counts
• sample URLs
• sample titles
• queries where it appeared
• capture date
• classification source: rule or manual override

If someone disagrees with a category, you want to fix the rule or override, not argue from memory.

Where the SERP API fits

The SERP API is the collection layer. The market map is your analysis layer.

A simple workflow:

1. Collect results for a keyword set
2. Normalize titles, URLs, snippets, and positions
3. Classify domains and page types
4. Aggregate by domain
5. Review unknown or high-impact domains
6. Use the map to guide research questions

If you need structured result data for this workflow, TalorData can support the SERP collection step while your team owns the classification logic.

Final thought

A SERP market map will not answer every strategy question.

But it can show who repeatedly appears in front of searchers, which page formats are common, and where review sites, communities, media, or vendor pages shape the market conversation.

That is a useful starting point before deeper research.

If you have built a similar map, I would be interested in how you classify domains that do not fit cleanly into one category.