How to Monitor Competitor SEO Rankings with a SERP API

Competitor Rankings Monitoring

Competitor monitoring reveals:

• Market share shifts: Who is gaining or losing visibility
• Content gaps: Topics competitors rank for that you don't
• Strategy changes: New pages, targeting shifts, rebrands
• Opportunity detection: Keywords your competitors abandoned

Core Monitoring Strategy

1. Identify target competitors
2. Define shared keyword universe
3. Track positions daily
4. Detect movements and patterns
5. Alert on significant changes

Building the Monitor

Step 1: Define Your Keyword Universe

keywords = [
    "serp api",
    "google search api",
    "rank tracker",
    "seo monitoring tool",
    "google results api"
]

competitors = [
    "serper.dev",
    "dataforseo.com",
    "serpapi.com",
    "brightdata.com"
]

Step 2: Track Competitor Presence

import requests
from datetime import datetime

API_KEY = "your-key"
URL = "https://api.serpbase.dev/google/search"

def check_competitors(keyword, competitors, gl="us"):
    resp = requests.post(URL, headers={
        "X-API-Key": API_KEY,
        "Content-Type": "application/json"
    }, json={"q": keyword, "gl": gl})
    data = resp.json()

    results = []
    for comp in competitors:
        for r in data.get("organic", []):
            if comp in r.get("link", ""):
                results.append({
                    "keyword": keyword,
                    "competitor": comp,
                    "position": r["position"],
                    "title": r["title"],
                    "url": r["link"],
                    "timestamp": datetime.now().isoformat()
                })
                break
        else:
            results.append({
                "keyword": keyword,
                "competitor": comp,
                "position": None,
                "timestamp": datetime.now().isoformat()
            })
    return results

Step 3: Detect Movements

import pandas as pd

def detect_movements(yesterday_file, today_file):
    yesterday = pd.read_csv(yesterday_file)
    today = pd.read_csv(today_file)

    merged = yesterday.merge(
        today,
        on=["keyword", "competitor"],
        suffixes=("_prev", "_curr")
    )

    merged["change"] = merged["position_prev"] - merged["position_curr"]

    gained = merged[merged["change"] > 0].sort_values("change", ascending=False)
    lost = merged[merged["change"] < 0].sort_values("change")

    print("=== Competitors Gaining Ground ===")
    for _, row in gained.head(5).iterrows():
        print(f"{row['competitor']} on '{row['keyword']}': +{row['change']} spots")

    print("=== Competitors Losing Ground ===")
    for _, row in lost.head(5).iterrows():
        print(f"{row['competitor']} on '{row['keyword']}': {row['change']} spots")

    return merged

Step 4: Alert on Changes

import smtplib
from email.message import EmailMessage

def send_alert(changes_df, threshold=5):
    significant = changes_df[abs(changes_df["change"]) >= threshold]
    if significant.empty:
        return

    msg = EmailMessage()
    msg.set_content(significant.to_string())
    msg["Subject"] = f"Competitor Alert: {len(significant)} significant movements"
    msg["To"] = "[email protected]"

    with smtplib.SMTP("smtp.example.com") as s:
        s.send_message(msg)

Step 5: Content Gap Analysis

def find_content_gaps(keyword, my_domain, competitors):
    resp = requests.post(URL, headers=headers, json={"q": keyword})
    data = resp.json()

    my_rank = None
    comp_presence = {}

    for r in data.get("organic", []):
        link = r["link"]
        if my_domain in link:
            my_rank = r["position"]
        for comp in competitors:
            if comp in link:
                comp_presence[comp] = r["position"]

    return {
        "keyword": keyword,
        "my_rank": my_rank,
        "competitors_ranking": comp_presence,
        "gap": all(comp in comp_presence for comp in competitors) and my_rank is None
    }

Visualization with a Simple Dashboard

import matplotlib.pyplot as plt
import pandas as pd

def plot_competitor_timeline(history_file):
    df = pd.read_csv(history_file)
    for comp in df["competitor"].unique():
        comp_data = df[df["competitor"] == comp]
        plt.plot(comp_data["timestamp"], comp_data["position"], label=comp)

    plt.gca().invert_yaxis()
    plt.xlabel("Date")
    plt.ylabel("Position")
    plt.title("Competitor Ranking History")
    plt.legend()
    plt.show()

Cost Breakdown

Best Practices

1. Focus on overlapping keywords — track terms where you and competitors both appear
2. Monitor SERP features — featured snippets and PAA are often more valuable than position 1
3. Track new entrants — detect when a new competitor appears for your target keywords
4. Correlate with traffic — use Google Search Console data alongside rank tracking
5. Weekly reports, daily alerts — review trends weekly but get instant alerts for drops

A well-built competitor monitoring system turns raw SERP data into actionable competitive intelligence. With SerpBase at $0.30/1k, you can track thousands of keyword-competitor pairs for less than the cost of a single SaaS tool subscription.

Competitor Monitoring Setup

A competitor ranking monitor should track more than position changes. The useful version explains why a competitor moved and whether the change matters.

Include these fields in each snapshot:

A good alert is specific: "Competitor X entered top 3 for google search api pricing in US desktop results" is much more useful than "ranking changed."

Related reading: SERP feature monitoring, rank tracking API for SEO tools, and site query audits.

FAQ

Should you track every competitor keyword?

No. Start with keywords that connect to revenue, pricing, alternatives, and comparison intent. A smaller clean keyword set is easier to act on.

How do you avoid noisy alerts?

Require a change to persist for more than one crawl or cross a meaningful threshold, such as moving into the top 3 or dropping out of page one.