DEV Community: API Serpent

I Wasted 3 Days Fighting the YouTube API Quota Before Writing 12 Lines of Code That Just Worked

API Serpent — Mon, 03 Aug 2026 03:30:25 +0000

I want to share something embarrassing
because I keep seeing other developers
make the same mistake.

Last quarter I was building a competitor
analysis tool. I needed to pull YouTube
channel data — subscriber counts, view
totals, video performance — for about
200 channels in my niche.

Simple enough, I thought.

Day 1: Setting up the "official" way

I went to the YouTube Data API docs.

Created a Google Cloud project.
Enabled the YouTube Data API v3.
Set up billing (required, even for free tier).
Generated API credentials.
Wrote the first request.

It worked. Great.

Then I checked the quota.

10,000 units per day
1 search request = 100 units
200 channels ÷ ~5 per search = 40 searches needed
40 searches × 100 units = 4,000 units
OK, I have headroom. Let me also pull
video details for each channel.
200 channels × ~50 videos = 10,000 video requests
10,000 video requests × 1 unit = 10,000 units
I had already used 4,000 units on searches.

Total needed: 14,000.
Daily limit: 10,000.

I couldn't even complete one full run
before hitting the quota.

Day 2: Applying for more quota

Google has a form for this.

You explain your use case.
You estimate your needs.
You wait.

The documentation says
"typically 5-7 business days."

In practice? 14 days. Sometimes more.
Sometimes denied with no explanation.

I'm sitting on a half-built tool,
waiting for a form response.

Day 3: Reading documentation I should

have read on Day 1

Deep in the YouTube API docs, I found this:

"Quota is not a replacement for
a well-designed application."

Which is Google's polite way of saying:
if you need more than 100 searches per day,
the free YouTube API was not designed for you.

The actual path to higher quota involves:

Demonstrating significant user base
Compliance review
Sometimes a commercial agreement

For a developer building a new tool?
That path is months away.

The 12 lines that ended the 3-day nightmare

I found that Serpent API had a YouTube
search endpoint. No Google Cloud project.
No quota system. No form to fill out.

import requests

def get_channel_stats(channel_names: list, api_key: str) -> list:
    results = []
    for name in channel_names:
        # Search for channel
        search = requests.get(
            "https://apiserpent.com/api/social/youtube/search",
            params={"q": name, "type": "channel", "num": 1},
            headers={"X-API-Key": api_key}
        ).json()

        if search.get("channels"):
            channel = search["channels"][0]
            results.append({
                "name": channel["title"],
                "subscribers": channel["subscriberCount"],
                "total_views": channel["viewCount"],
                "video_count": channel["videoCount"]
            })
    return results

# All 200 channels. No quota. No waiting.
stats = get_channel_stats(my_competitor_list, API_KEY)

Ran it.

Got data for all 200 channels.

No quota errors.
No Google Cloud billing dashboard.
No pending form submissions.

The entire 3-day detour was avoidable.

What I learned (the part worth keeping)

I'm not writing this to promote the API
I ended up using. I'm writing it because
the pattern of "spend days fighting
official infrastructure before finding
the simpler path" is a trap I fall into
constantly.

The official API is always the first
result. It has the best documentation.
It feels like the "correct" choice.

But official ≠ right for every use case.

YouTube's official API is excellent if
you're building an app where users
authenticate with their own Google
accounts and you need to manage their
content. That's what it was designed for.

It was not designed for developer
research tools, competitor analysis,
or anything that needs to query
public data at volume.

Knowing the design intent of an API
before spending three days on it
would have saved me three days.

Has this happened to you?

Which official API have you fought
the hardest before finding a better
path?

I'm genuinely curious whether this
is a common pattern or I'm just
particularly stubborn.

The tool I ended up using is
Serpent API —
YouTube from $0.11/1K,
Instagram from $0.58/1K,
no quota system.
I'm disclosing this upfront because
undisclosed product mentions are
the thing that makes dev.to worse.

Needed YouTube + Instagram Data in One Script. Here's the Cleanest Way to Do It in 2026.

API Serpent — Sat, 25 Jul 2026 06:45:36 +0000

Getting YouTube and Instagram data officially requires two separate OAuth setups, two approval processes, and two quota systems. Here's how to do it with one API key and 10 lines of code instead.

You're building a creator research tool. Or a social media audit dashboard. Or an AI agent that researches brands.

You need YouTube channel stats and Instagram profile data for the same person or brand. Together. In one workflow.

The official path:

YouTube: Google Cloud project + credentials + 100 searches/day quota + quota extension form + weeks of waiting
Instagram: Facebook Developer account + Meta app review (2-8 weeks) + OAuth setup + token refresh logic

That's two completely separate authentication systems, two approval processes, and two quota systems to manage before writing a single line of product code.

There's a faster way.

One API Key for Both

import requests

BASE_URL = "https://apiserpent.com/api/social"
HEADERS = {"X-API-Key": "YOUR_SERPENT_KEY"}

def research_creator(youtube_handle: str, instagram_username: str) -> dict:
    """Get full creator profile across YouTube + Instagram in parallel."""

    # YouTube channel stats
    yt = requests.get(f"{BASE_URL}/youtube/channel",
        params={"id": youtube_handle}, headers=HEADERS).json()

    # Instagram profile stats
    ig = requests.get(f"{BASE_URL}/instagram/profile",
        params={"username": instagram_username}, headers=HEADERS).json()

    return {
        "name": yt.get("title"),
        "youtube": {
            "subscribers": yt.get("subscribers"),
            "total_views": yt.get("totalViews"),
            "video_count": yt.get("videoCount")
        },
        "instagram": {
            "followers": ig.get("followers"),
            "engagement_rate": ig.get("engagementRate"),
            "avg_likes": ig.get("avgLikes")
        },
        "cross_platform_reach": yt.get("subscribers", 0) + ig.get("followers", 0)
    }


# Research a creator across both platforms
creator = research_creator("@mkbhd", "mkbhd")
print(f"YouTube subscribers: {creator['youtube']['subscribers']:,}")
print(f"Instagram followers: {creator['instagram']['followers']:,}")
print(f"Instagram engagement: {creator['instagram']['engagement_rate']}%")
print(f"Total combined reach: {creator['cross_platform_reach']:,}")

No Google Cloud. No Meta app review. No OAuth on either side.

Scaling to a bulk research workflow

import concurrent.futures

creators = [
    {"yt": "@mkbhd",      "ig": "mkbhd"},
    {"yt": "@linustechtips", "ig": "linustech"},
    {"yt": "@mrwhosetheboss", "ig": "mrwhosetheboss"},
]

def process_creator(c):
    return research_creator(c["yt"], c["ig"])

# Run all in parallel
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(process_creator, creators))

# Sort by Instagram engagement rate
ranked = sorted(results, key=lambda x: x["instagram"]["engagement_rate"], reverse=True)
for r in ranked:
    print(f"{r['name']}: {r['instagram']['engagement_rate']}% engagement, "
          f"{r['instagram']['followers']:,} IG followers")

Check 50 creators across both platforms in a few seconds. No quota walls. No token expiry errors mid-run.

What it costs

At Scale tier ($500 deposit, drawn down as you use it):

YouTube: $0.01 per 1,000 calls
Instagram: $0.58 per 1,000 profile checks

Checking 50 creators (50 YouTube + 50 Instagram calls): $0.03 total.

Monthly cost for a tool checking 10,000 creators per month: $5.90.

Real use cases this unlocks

Influencer discovery platforms — score creators by YouTube growth + Instagram engagement in one pass
Agency reporting tools — automated weekly snapshots of client and competitor social performance
AI research agents — function call that returns complete social profile for any creator or brand
Brand monitoring — track competitor brand presence across both platforms automatically

Limitations

Instagram: public accounts only
YouTube: read-only (no uploading or account management)
Not a publishing API — this is for data retrieval

Stop Querying Google Every Time. Here's a SERP Caching Strategy That Cut My API Cost by 73%

API Serpent — Fri, 24 Jul 2026 12:50:57 +0000

If you're running any kind of rank tracker, SEO tool, or search-data pipeline, there's a good chance you're making redundant API calls you don't need to.

I was querying the same keywords daily — sometimes multiple times a day — and paying for it every single time. Same query. Same result. Full price.

After some embarrassingly basic analysis, I found 73% of my SERP queries returned results that hadn't meaningfully changed since the last check.

Here's the caching layer I built, and the logic for deciding what's worth re-querying vs. what's fine to serve from cache.

The Core Problem: Not All Keywords Change at the Same Rate

Brand keywords for stable companies: changes maybe once a month. "Breaking news" queries: can change every 5 minutes. Long-tail informational keywords: changes maybe every 2-4 weeks. Transactional/price-sensitive keywords: changes every 1-7 days.

If you're checking everything on the same schedule, you're massively over-querying stable keywords and potentially under-querying volatile ones.

Step 1: Classify your keywords by volatility

import hashlib
import json
import redis
from datetime import timedelta
from enum import Enum

class KeywordVolatility(Enum):
    REALTIME = "realtime"      # News, breaking events: TTL 15 min
    HIGH = "high"              # Trending topics, prices: TTL 4 hours  
    MEDIUM = "medium"          # Standard commercial: TTL 24 hours
    LOW = "low"                # Brand/evergreen: TTL 72 hours

VOLATILITY_TTL = {
    KeywordVolatility.REALTIME: timedelta(minutes=15),
    KeywordVolatility.HIGH: timedelta(hours=4),
    KeywordVolatility.MEDIUM: timedelta(hours=24),
    KeywordVolatility.LOW: timedelta(hours=72),
}

def classify_keyword_volatility(keyword: str) -> KeywordVolatility:
    """
    Classify keyword by expected SERP change rate.
    Crude heuristic — refine with your own data over time.
    """
    keyword_lower = keyword.lower()

    realtime_signals = ["news", "today", "now", "live", "breaking", "latest"]
    high_signals = ["price", "cost", "deal", "vs", "2026", "sale", "discount"]
    low_signals = ["what is", "how to", "guide", "tutorial", "definition"]

    if any(s in keyword_lower for s in realtime_signals):
        return KeywordVolatility.REALTIME
    if any(s in keyword_lower for s in high_signals):
        return KeywordVolatility.HIGH
    if any(s in keyword_lower for s in low_signals):
        return KeywordVolatility.LOW

    return KeywordVolatility.MEDIUM  # Default

Step 2: Build the caching wrapper

import requests

class CachedSERPClient:
    def __init__(self, api_key: str, redis_client: redis.Redis):
        self.api_key = api_key
        self.redis = redis_client
        self.base_url = "https://apiserpent.com/api/search"

    def _cache_key(self, query: str, engine: str) -> str:
        raw = f"{query}:{engine}".lower().strip()
        return f"serp:{hashlib.md5(raw.encode()).hexdigest()}"

    def search(
        self,
        query: str,
        engine: str = "google",
        volatility: KeywordVolatility = None,
        force_refresh: bool = False
    ) -> dict:
        # Auto-classify if not provided
        if volatility is None:
            volatility = classify_keyword_volatility(query)

        cache_key = self._cache_key(query, engine)
        ttl = VOLATILITY_TTL[volatility]

        # Check cache first (unless force refresh)
        if not force_refresh:
            cached = self.redis.get(cache_key)
            if cached:
                result = json.loads(cached)
                result["_cache_hit"] = True
                result["_volatility"] = volatility.value
                return result

        # Cache miss — query the API
        response = requests.get(
            self.base_url,
            params={"q": query, "engine": engine, "num": 10},
            headers={"X-API-Key": self.api_key},
            timeout=10
        )
        response.raise_for_status()
        data = response.json()

        # Store in cache
        data["_cache_hit"] = False
        data["_volatility"] = volatility.value
        self.redis.setex(cache_key, int(ttl.total_seconds()), json.dumps(data))

        return data

Step 3: Track your cache hit rate to measure savings

class SERPMetrics:
    def __init__(self, redis_client: redis.Redis):
        self.redis = redis_client

    def record_query(self, cache_hit: bool, volatility: str):
        today = datetime.now().strftime("%Y-%m-%d")
        key = f"serp_metrics:{today}"

        self.redis.hincrby(key, "total_queries", 1)
        self.redis.expire(key, 60 * 60 * 24 * 30)  # Keep 30 days

        if cache_hit:
            self.redis.hincrby(key, "cache_hits", 1)
        else:
            self.redis.hincrby(key, "api_calls", 1)

        self.redis.hincrby(key, f"volatility_{volatility}", 1)

    def get_daily_stats(self, date: str = None) -> dict:
        date = date or datetime.now().strftime("%Y-%m-%d")
        raw = self.redis.hgetall(f"serp_metrics:{date}")

        stats = {k.decode(): int(v) for k, v in raw.items()}
        total = stats.get("total_queries", 0)
        hits = stats.get("cache_hits", 0)

        return {
            **stats,
            "cache_hit_rate": hits / total if total > 0 else 0,
            "estimated_savings_pct": (hits / total * 100) if total > 0 else 0
        }

Real results from my pipeline

Before caching: 14,200 API calls/month → $0.85 at Scale tier pricing After caching: 3,820 API calls/month → $0.23 at Scale tier pricing

73% reduction. $0.62/month saved.

I know — the absolute number is tiny because Serpent API is cheap. But the pattern matters at scale. If you're on a more expensive provider or running higher volumes, the same logic cuts proportionally:

SerpAPI at $100/10K pages: 14,200 calls → $142/month → with caching → $38/month
The architectural pattern is the same regardless of provider

When to force-refresh (bypass cache)

# Force refresh on explicit user request
result = client.search("apiserpent.com competitors", force_refresh=True)

# Force refresh if SERP change events detected
# (e.g., Google core update announcements in your monitoring)
if google_core_update_detected():
    client.search(keyword, force_refresh=True)

The default should always be cache-first. Force refresh is for explicit user actions or known volatility events.

My AI Agent Was Confidently Wrong Until I Gave It Live SERP Data

API Serpent — Fri, 24 Jul 2026 12:32:31 +0000

I built a competitive research agent with LangChain earlier this year.

It answered questions about market positioning, competitor pricing, and keyword gaps. It sounded confident every time.

It was also using training data from 2024 to answer questions about July 2026.

The agent didn't know that one of my tracked competitors had rebranded and changed pricing three months ago. It didn't know a new player had entered the space. It kept citing rankings that hadn't existed in six months.

This is the silent failure mode of AI agents that most builder tutorials skip: hallucinated freshness. The model sounds present-tense but thinks in past-tense.

The fix isn't RAG on static documents

A lot of teams solve this with RAG — chunking PDFs, internal docs, product pages into a vector store and pulling relevant context at query time.

RAG is great. But for competitive intelligence and live search data, it breaks at the source. If your documents are stale, your RAG is stale. You need live retrieval, not just smarter retrieval.

The pattern that actually worked for me:

import requests

def get_live_serp_context(query: str, api_key: str) -> dict:
    """
    Pull real SERP data before the LLM reasons over competitive questions.
    Prevents training-data hallucination on market positioning queries.
    """
    response = requests.get(
        "https://apiserpent.com/api/search",
        params={"q": query, "engine": "google", "num": 10},
        headers={"X-API-Key": api_key}
    )
    data = response.json()

    return {
        "organic_results": [
            {
                "position": r["position"],
                "title": r["title"],
                "url": r["url"],
                "snippet": r["snippet"]
            }
            for r in data.get("organic_results", [])[:5]
        ],
        "people_also_ask": data.get("related_questions", []),
        "timestamp": data.get("search_metadata", {}).get("processed_at")
    }

# In your agent tool definition:
def competitive_research_tool(competitor_name: str) -> str:
    """
    Use this when asked about competitor positioning, pricing, or rankings.
    Always call this before answering competitive questions — never use training data alone.
    """
    queries = [
        f"{competitor_name} pricing 2026",
        f"{competitor_name} alternatives",
        f"vs {competitor_name}"
    ]

    context_blocks = []
    for q in queries:
        serp = get_live_serp_context(q, api_key="YOUR_KEY")
        context_blocks.append(f"Query: {q}\nResults: {serp['organic_results']}")

    return "\n\n".join(context_blocks)

The key change: the agent now calls competitive_research_tool before any reasoning about competitors. The system prompt explicitly says: "Never answer questions about market positioning, pricing, or rankings without calling this tool first."

What changed after wiring this up

Before: Agent answered confidently with 6-12 month old positioning data
After: Agent grounds every competitive claim in results from the last 24-48 hours

The cost at our query volume (roughly 3,000 competitive research queries/month): $0.18/month using Serpent API's Scale tier at $0.06/10K pages.

For context, the first version of this agent used SerpAPI. Same query volume: $30/month. We switched. Same data quality, 99.4% cost reduction.

Conclusion
AI agents in 2026 are increasingly MCP-native and tool-heavy. The tooling is mature. The failure mode isn't usually "the agent can't call tools." It's "the agent calls the wrong tool, or no tool, for questions that feel like knowledge but are actually live-data questions."

Anything touching: competitor pricing, SERP rankings, brand mentions, market positioning — treat it as a live-data problem, not a training-data problem.

Your agent will thank you. So will your users who catch it when it's wrong.

How to Track Your Perplexity AI Rankings — Free Checker + API Guide (2026)

API Serpent — Thu, 23 Jul 2026 18:16:54 +0000

Perplexity reached 230 million monthly active users in Q1 2026. Every one of those users sees explicitly-cited sources inline with every answer. When Perplexity answers "best tool for X" it names specific brands and links to specific pages.

This means your brand is either cited — or a competitor is. There is no "page 2" on Perplexity. You either appear in the answer or you don't.

This guide covers: how to check if Perplexity is citing your brand right now (free, manual), what factors determine whether you get cited, and how to automate the tracking so you know the moment your citation changes.

Free check: is Perplexity citing you right now?
Run these steps in the next 5 minutes:

Open perplexity.ai
Search the 5 queries your customers would use to find you — NOT your brand name, but category queries like "best rank tracking API" or "cheapest SERP API for developers"
Note whether your domain appears in the cited sources (the small source icons and links Perplexity shows beneath each answer section)
Note which competitor domains appear instead of yours
Do the same 5 queries in ChatGPT, Claude, and Gemini — the results will be different because each engine uses a different search index
What you will find in most cases: your results are inconsistent across engines. You might appear in Perplexity but not Claude. You might appear in Gemini but not ChatGPT. This is expected — each engine uses a different underlying search index.

Why the indexes differ: ChatGPT uses Bing. Claude uses Brave Search. Gemini uses Google. Perplexity uses its own proprietary index. Being well-ranked on Google helps Gemini citations but has almost no correlation with Perplexity citations.

The 6 factors that determine Perplexity citations

Based on a study of 83,670 Perplexity citations by Analyze AI, these factors have the strongest correlation with appearing in Perplexity's top-3 citations:

Domain authority from third-party sources: brands mentioned on trusted industry outlets, review sites (G2, Capterra), and news publications are far more likely to be recommended. Perplexity trusts third-party validation over self-reported content.
Content recency: Perplexity has a stronger recency bias than ChatGPT. Content updated in the last 90 days is significantly more likely to be cited. The correlation between freshness and Top-3 position: Spearman -0.36 (p < 0.01).
Structured lists and statistics: pages with research, case studies, and specific data points see a 40% visibility boost in Perplexity answers (Seer Interactive, 10,000 query analysis). Perplexity extracts factual, structured content more readily than long-form narrative.
Multi-source corroboration: Perplexity rarely relies on a single source for any claim. It blends your site's content with G2 reviews, social media mentions, and third-party articles. Having consistent information across multiple indexed sources helps.
Page load speed and indexability: Perplexity's crawler treats JavaScript-heavy pages poorly. Server-rendered content with fast load times gets indexed more completely.
Schema markup: pages with FAQ schema, HowTo schema, and structured data get 30-40% higher AI visibility according to independent research. Perplexity extracts structured data efficiently.

Automated Perplexity rank tracking: the API approach

Manual checking works for a one-time audit. For ongoing tracking — knowing when your citations change, when a competitor overtakes you, which queries you're winning vs losing — you need automated monitoring.

import requestsimport jsonfrom datetime import datetimedef check_perplexity_rank(    keyword: str,    api_key: str,    your_domain: str = None) -> dict:    """    Query Perplexity via Sonar API and return     structured citation data.        Returns citation URLs, position, visibility score,    and which competitors are being cited instead of you.    """    resp = requests.get(        "https://apiserpent.com/api/ai/rank",        params={            "keyword": keyword,            "engines": "perplexity"        },        headers={"X-API-Key": api_key},        timeout=45    )    resp.raise_for_status()    data = resp.json()    perplexity_data = data["results"].get("perplexity", {})    result = {        "keyword": keyword,        "timestamp": datetime.now().isoformat(),        "visibility_score": perplexity_data.get("visibility_score", 0),        "cited": perplexity_data.get("cited", False),        "citations": perplexity_data.get("citations", []),        "competitors_cited": perplexity_data.get("competitor_citations", [])    }    if your_domain:        result["your_position"] = next(            (c["position"] for c in result["citations"]             if your_domain in c.get("url", "")),            None        )    return result# Track 10 keywords weeklyKEYWORDS = [    "perplexity rank tracker",    "best perplexity rank tracker tool",    "perplexity keyword rank checker",    "track brand mentions perplexity",    "perplexity ai visibility"]API_KEY = "your_serpent_api_key"for kw in KEYWORDS:    result = check_perplexity_rank(kw, API_KEY, "apiserpent.com")    cited = "✓ CITED" if result["cited"] else "✗ NOT CITED"    score = result["visibility_score"]    competitors = result["competitors_cited"][:3]    print(f"{kw}")    print(f"  Status: {cited} | Score: {score}/100")    if competitors:        print(f"  Competitors winning: {', '.join(competitors)}")    print()

Improving your Perplexity citation rate: the 90-day action plan

Month 1 — Fix indexability and structure:

Add FAQ schema to your top 5 pages most likely to be queried by your target audience
Ensure Perplexity's crawler can access your pages (check robots.txt doesn't block common AI crawlers)
Update any page that hasn't been modified in 90+ days with at least one new statistic, date-stamped section, or revised paragraph
Month 2 — Build third-party citations:
Submit to G2, Capterra, Trustpilot — Perplexity specifically pulls from these review platforms
Get mentioned in 2-3 "best X for Y" articles on established tech publications — Perplexity trusts these heavily
Create one original data study or survey in your niche — original research is Perplexity's most-cited content type
Month 3 — Track and optimise:
Run the automated tracker weekly
When a competitor gains citations you were holding, examine their page — what changed?
A/B test page structure changes and measure citation impact 2-4 weeks later

Rank Tracker API: How to Build a Multi-Engine Keyword Rank Checker in Python (2026 Guide)

API Serpent — Fri, 17 Jul 2026 13:19:07 +0000

Wants to build their own rank tracker rather than pay $99-500/month for a dashboard tool they can only partly customise?

This guide covers everything you need: what a rank tracker API actually returns, how to query it across multiple search engines, how to handle the data, and how to build a simple scheduled rank checker in under 100 lines of Python.

API used throughout: Serpent API

What a rank tracker API actually returns (and what yours should)

Not all rank tracker APIs return the same data. The minimum viable response for a rank checker contains: keyword, search engine, target domain, rank position (integer), URL of the ranked page, title and snippet.

A modern rank tracker API in 2026 should also return:

AI Overview presence flag: is there a generative AI block above organic results for this query?
AI Overview cited sources: does your domain appear inside the AI Overview?
Pixel Y coordinate: where on the rendered page does your result actually appear?
Position 1 can be below the fold if an AI Overview occupies 300px above it.

SERP features above your result: ads, Local Pack, Shopping — how many elements push your result down?
Device and location context: mobile vs desktop rankings differ; country-level targeting affects results

Why pixel position matters specifically in 2026: AI Overviews appear on ~55% of informational Google queries and occupy 200-400px before organic results begin. A rank tracker that only returns "position 1" without telling you whether position 1 is above or below the fold is giving you incomplete data.

The keyword cannibalization problem (and why two rank tracker APIs are better than one)

A critical finding from building rank tracking systems: if you query Google rank position and AI rank citation position separately, you get two different signals that together tell a much more complete story.
Signal 1 — Traditional rank position (this article): where does your domain appear in the organic list? This is what all rank trackers have measured since 2005.
Signal 2 — AI citation position (separate endpoint): does your brand appear in the AI-generated answer above the organic list? A page can rank position 1 organically and not be cited in the AI Overview. A page can rank position 15 and be cited in the AI Overview. These are independent signals.

Building the rank tracker: Python implementation

Here is the complete implementation for a multi-engine keyword rank checker. It queries Google, Bing, Yahoo, and DuckDuckGo simultaneously and returns a structured rank report.

1. Setup and authentication

pip install requests python-dotenv schedule pandas
# config.pyimport osfrom dotenv import load_dotenvload_dotenv()API_KEY = os.getenv("SERPENT_API_KEY")BASE_URL = "https://apiserpent.com/api"

2. The core rank checker function

# rank_tracker.pyimport requestsfrom dataclasses import dataclassfrom typing import Optional@dataclassclass RankResult:    keyword: str    engine: str    domain: str    rank: Optional[int]        # None = not in top 100    url: Optional[str]    pixel_y: Optional[int]     # vertical position on page    above_fold: Optional[bool] # True = visible without scroll    in_ai_overview: bool       # cited in AI Overview    ai_overview_present: bool  # AIO exists for this queryclass RankChecker:    ENGINES = ["google", "bing", "yahoo", "duckduckgo"]    FOLD_THRESHOLD_PX = 600  # typical laptop fold line    def __init__(self, api_key: str):        self.session = requests.Session()        self.session.headers["X-API-Key"] = api_key    def check_rank(        self,        keyword: str,        domain: str,        engine: str = "google",        country: str = "us",        device: str = "desktop"    ) -> RankResult:        """Check rank for a single keyword on a single engine."""        resp = self.session.get(            f"https://apiserpent.com/api/search",            params={                "q": keyword,                "engine": engine,                "gl": country,                "device": device,                "num": 100  # check top 100 results            },            timeout=20        )        resp.raise_for_status()        data = resp.json()        # Find domain in organic results        rank = None        ranked_url = None        pixel_y = None        above_fold = None        for result in data.get("organic_results", []):            if domain.lower() in result.get("link", "").lower():                rank = result["position"]                ranked_url = result["link"]                pos = result.get("pixel_position", {})                pixel_y = pos.get("y")                if pixel_y is not None:                    above_fold = pixel_y < self.FOLD_THRESHOLD_PX                break        # Check AI Overview        aio = data.get("ai_overview", {})        ai_overview_present = bool(aio)        in_ai_overview = any(            domain.lower() in source.get("link", "").lower()            for source in aio.get("sources", [])        )        return RankResult(            keyword=keyword,            engine=engine,            domain=domain,            rank=rank,            url=ranked_url,            pixel_y=pixel_y,            above_fold=above_fold,            in_ai_overview=in_ai_overview,            ai_overview_present=ai_overview_present

3. Multi-engine rank report

    def check_all_engines(        self,        keyword: str,        domain: str,        engines: list = None    ) -> list[RankResult]:        """Check rank across multiple engines simultaneously."""        import concurrent.futures        engines = engines or self.ENGINES        results = []        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:            futures = {                executor.submit(                    self.check_rank, keyword, domain, engine                ): engine                for engine in engines            }            for future in concurrent.futures.as_completed(futures):                try:                    results.append(future.result())                except Exception as e:                    print(f"Error on {futures[future]}: {e}")        return results    def bulk_check(        self,        keywords: list[str],        domain: str,        engines: list = None    ) -> dict:        """        Check multiple keywords across engines.        Returns dict keyed by keyword.        """        return {            kw: self.check_all_engines(kw, domain, engines)            for kw in keywords        }

4. Reporting and output

import pandas as pdfrom datetime import datetimedef results_to_dataframe(    results: dict,    domain: str) -> pd.DataFrame:    """Convert rank results to a pandas DataFrame."""    rows = []    for keyword, engine_results in results.items():        for r in engine_results:            rows.append({                "date": datetime.now().date(),                "keyword": r.keyword,                "engine": r.engine,                "domain": domain,                "rank": r.rank or "Not in top 100",                "url": r.url or "—",                "pixel_y": r.pixel_y,                "above_fold": r.above_fold,                "in_ai_overview": r.in_ai_overview,                "ai_overview_present": r.ai_overview_present            })    return pd.DataFrame(rows)# Usage examplefrom config import API_KEYchecker = RankChecker(API_KEY)keywords = [    "rank tracker api",    "keyword ranking api",    "google rank checker api",    "serp tracker google yahoo bing"]print(f"Checking {len(keywords)} keywords across 4 engines...")results = checker.bulk_check(keywords, "apiserpent.com")df = results_to_dataframe(results, "apiserpent.com")df.to_csv(f"rank_report_{datetime.now().date()}.csv", index=False)# Summaryfor kw, engine_results in results.items():    print(f"\n{kw}:")    for r in engine_results:        status = f"rank {r.rank}" if r.rank else "not found"        fold = "above fold" if r.above_fold else "below fold" if r.above_fold is False else "n/a"        aio = "in AIO" if r.in_ai_overview else ("AIO present" if r.ai_overview_present else "no AIO")        print(f"  {r.engine:12} → {status:20} {fold:12} {aio}")

5. Scheduled daily tracking

import scheduleimport timedef daily_rank_check():    """Run daily at 6am and save results."""    checker = RankChecker(API_KEY)    results = checker.bulk_check(KEYWORDS, TARGET_DOMAIN)    df = results_to_dataframe(results, TARGET_DOMAIN)    # Append to master CSV    master_path = "rank_history.csv"    try:        existing = pd.read_csv(master_path)        pd.concat([existing, df]).to_csv(master_path, index=False)    except FileNotFoundError:        df.to_csv(master_path, index=False)    print(f"[{datetime.now()}] Daily rank check complete. {len(df)} rows saved.")schedule.every().day.at("06:00").do(daily_rank_check)while True:    schedule.run_pending()    time.sleep(60)

Cost calculation for your rank tracker

Before building, estimate your monthly API cost. The formula:

# Cost calculatorkeywords = 500       # keywords you trackengines = 4          # Google, Bing, Yahoo, DuckDuckGochecks_per_day = 1   # daily trackingdays = 30monthly_calls = keywords * engines * checks_per_day * days# = 500 × 4 × 1 × 30 = 60,000 calls# Serpent API Scale tier: $0.03 per 10,000 pagescost_per_call = 0.03 / 10000 * 10  # $0.03 per 10K, so per 1K = $0.003monthly_cost = monthly_calls * cost_per_call / 1000print(f"Monthly calls: {monthly_calls:,}")print(f"Monthly cost: ${monthly_cost:.2f}")# → Monthly calls: 60,000# → Monthly cost: $0.18

Decision matrix: when to use a rank tracker API vs a rank tracking tool

Factor	Use an API	Use a dashboard tool
Custom dashboard	Yes ✓ — build your own	No — use theirs
Multiple clients	Yes ✓ — white label possible	Expensive at scale
Technical setup	Required — code needed	No code needed
Data ownership	Yes ✓ — export freely	Locked in platform
Cost at 500 keywords	Serpent: ~$0.18/mo	Tools: $99-500/mo
AI Overview tracking	Yes ✓ — returned in base response	Rare, often add-on
Pixel positions	Yes ✓ — unique to Serpent	Not available anywhere

SERP API Pricing in 2026: I Did the Math So You Don't Have To (Every Provider, Same Unit)

API Serpent — Fri, 17 Jul 2026 07:07:59 +0000

SERP API Pricing in 2026: The Math Nobody Does

Most developers compare SERP APIs by glancing
at the homepage price. This is almost always
the wrong comparison because every provider
quotes a different unit.

I converted all 9 major providers to
cost-per-1,000-searches at three real
volume tiers. Here's what I found.

Why the headline price is almost always wrong

SerpApi quotes monthly plan cost.

DataForSEO quotes per-request.

Serper quotes per-credit-pack.

ScraperAPI quotes per-credit where
1 Google search costs 25 credits.

Bright Data quotes per-result, not
per-search (one search = 10 results =
10 billable units).

Until you convert everything to the same
unit, you cannot compare them.

The conversion table

Provider	Per 1K at 10K/mo	Per 1K at 100K/mo	Credit expiry
Serpent API	$0.06	$0.03	Never ✓
DataForSEO (async)	$0.60	$0.60	Never ✓
Serper.dev	$1.00	$0.50	6 months
SerpApi Starter	$25.00	$15.00	Monthly ✗
Bright Data	$0.75–$1.50	$0.65+	N/A
ScrapingDog	$2.00	$0.29	Cycle ✗
ScraperAPI	$12.25 (effective)	$1.07	Monthly ✗
Oxylabs	$1.60/result	Varies	N/A
SearchAPI.io	$4.00	~$1.00	N/A

The ScraperAPI credit trap

ScraperAPI's Hobby plan: $49/month for
"100,000 API credits."

What the homepage doesn't say prominently:
1 structured Google SERP request = 25 credits.

100,000 credits ÷ 25 credits/search
= 4,000 actual Google searches
= $12.25 per 1,000 searches effective rate
That makes it the most expensive entry
tier on this list after SerpApi.

The credit expiry tax

SerpApi resets credits monthly. If your
usage is inconsistent — seasonal campaigns,
project-based workloads, quarterly audits —
you're paying for credits you never use.

At 60% average utilisation on a $75/month
plan:

python
plan_cost = 75          # $/month
utilisation = 0.60      # 60% used on average
credits_allocated = 5000
credits_used = credits_allocated * utilisation  # 3,000
effective_cost_per_1k = plan_cost / (credits_used / 1000)
# = $25.00 per 1,000 — not $15.00 as advertised

Real effective cost: $25/1K, not $15/1K.

The async vs synchronous problem

DataForSEO's $0.60/1K standard queue is
genuinely the cheapest raw rate — but
it's asynchronous:

python
# DataForSEO workflow (standard queue)
task_id = client.post_task(keyword)    # Step 1
time.sleep(30)                          # Wait
result = client.get_task(task_id)       # Step 2
# Then handle: not ready yet? retry logic.
# Timeout? Handle that too.
# Failed task? Resubmit.

vs synchronous:

python
# Serpent API
result = requests.get(
    "https://apiserpent.com/api/search",
    params={"q": keyword},
    headers={"X-API-Key": KEY}
)
# Done. No polling. No state management.

If your use case is overnight batch rank
tracking — async is fine. If a user is
waiting for results, async is wrong architecture.

How to calculate your real cost

python
def calculate_real_cost(
    monthly_volume: int,
    plan_cost: float,
    plan_credits: int,
    avg_utilisation: float = 1.0,  # 1.0 = use all credits
    credits_per_search: int = 1
) -> dict:
    """Calculate true effective cost per 1K searches."""

    actual_searches = (plan_credits / credits_per_search) * avg_utilisation
    effective_cost_per_1k = plan_cost / (actual_searches / 1000)

    return {
        "monthly_cost": plan_cost,
        "actual_searches": int(actual_searches),
        "effective_per_1k": round(effective_cost_per_1k, 2),
        "wasted_credits_cost": round(
            plan_cost * (1 - avg_utilisation), 2
        )
    }

# SerpApi Developer at 60% utilisation
print(calculate_real_cost(5000, 75, 5000, 0.60))
# {'monthly_cost': 75, 'actual_searches': 3000, 
#  'effective_per_1k': 25.0, 'wasted_credits_cost': 30.0}

# Serpent API Scale (credits never expire = 100% utilisation)
print(calculate_real_cost(100000, 3.0, 100000, 1.0))
# {'monthly_cost': 3.0, 'actual_searches': 100000,
#  'effective_per_1k': 0.03, 'wasted_credits_cost': 0.0}

The one feature that changes the cost calculation

Serpent API's credits never expire. This
means the utilisation adjustment is always
1.0 — you're never paying for capacity
you don't use.

Full comparison table with all providers:
apiserpent.com/blog/serp-api-pricing-comparison

10 free searches to test the data quality:
apiserpent.com — no card required.

What provider are you currently using?
Drop it in the comments — I'll run the
calculation for your actual volume.

AI Overviews Broke Rank Tracking. Here's What to Measure Instead.

API Serpent — Thu, 16 Jul 2026 08:46:00 +0000

AI Overviews Broke Rank Tracking

A stat that should change how you build
rank tracking tools:

The overlap between Google top-10 and
AI Overview citations dropped from 76%
to 38% in one year.

This means a page ranking #1 organically
now has less than a 40% chance of also
appearing in the AI Overview above it.

Traditional rank tracking is measuring
the wrong thing for half of all queries.

What the 2026 SERP actually looks like

For informational and "best X" queries
(~55% of all Google searches), the page
renders like this:

AI Overview (200-400px tall) │
│ Summarised answer │
│ Cited sources: [site1] [site2] │
├─────────────────────────────────────┤
│ People Also Ask │
├─────────────────────────────────────┤
│ #1 Organic result ← below fold │
│ #2 Organic result │
│ #3 Organic result │

Position 1 organically is below the fold
on a standard laptop screen.

The two metrics you actually need

Metric 1: Traditional rank position
Still useful. Not sufficient alone.

Metric 2: AI Overview citation status
New. Increasingly essential.

A page can rank #1 and not be in the AIO.
A page can rank #15 and be cited in the AIO.

Both exist. Both require different fixes.

Getting both from one API call

python
import requests

def get_full_serp_data(keyword: str, api_key: str) -> dict:
    """
    Returns rank position AND AI Overview 
    citation status in one call.
    """
    response = requests.get(
        "https://apiserpent.com/api/search",
        params={"q": keyword, "engine": "google"},
        headers={"X-API-Key": api_key}
    )
    data = response.json()

    # Traditional organic positions
    organic = [
        {
            "position": r["position"],
            "url": r["link"],
            # Pixel Y coordinate — unique feature
            # Tells you if result is above/below fold
            "pixel_y": r.get("pixel_position", {}).get("y"),
            "above_fold": r.get("pixel_position", {}).get("y", 999) < 600
        }
        for r in data.get("organic_results", [])
    ]

    # AI Overview — separate signal
    aio = data.get("ai_overview", {})
    aio_data = {
        "present": bool(aio),
        "text": aio.get("text", ""),
        "cited_sources": [
            s["link"] for s in aio.get("sources", [])
        ]
    }

    return {
        "keyword": keyword,
        "organic_results": organic,
        "ai_overview": aio_data,
        "your_page_rank": None,      # fill with your domain
        "your_page_in_aio": None,    # fill with your domain
    }

def analyse_for_domain(data: dict, domain: str) -> dict:
    """Check both signals for your specific domain."""
    rank = next(
        (r["position"] for r in data["organic_results"] 
         if domain in r["url"]), 
        None
    )
    in_aio = any(
        domain in url 
        for url in data["ai_overview"]["cited_sources"]
    )
    above_fold = next(
        (r["above_fold"] for r in data["organic_results"]
         if domain in r["url"]),
        False
    )
    return {
        "organic_rank": rank,
        "above_fold": above_fold,
        "in_ai_overview": in_aio,
        "aio_present": data["ai_overview"]["present"]
    }

# Example
keyword = "best SERP API 2026"
data = get_full_serp_data(keyword, "your_api_key")
result = analyse_for_domain(data, "apiserpent.com")

print(f"Rank: {result['organic_rank']}")
print(f"Above fold: {result['above_fold']}")
print(f"AIO present: {result['aio_present']}")
print(f"In AIO: {result['in_ai_overview']}")

The action matrix

Rank	In AIO	Action
Top 3	Yes	Maintain — you're winning both signals
Top 3	No	Update content structure — add definitions, lists, stats
4-10	Yes	AIO win offsets rank — prioritise AIO freshness
4-10	No	Both gaps — start with AIO optimisation
11+	Yes	AIO is your only visibility — exploit it
11+	No	Build links first, then AIO structure

Get started free

10 free Google searches at
apiserpent.com —
no card required. Returns organic rank,
AI Overview full text + sources, pixel
positions, PAA, Featured Snippets in
one JSON response.

Building an AI Citation Tracker in Python: Check if ChatGPT, Claude, Gemini, and Perplexity Recommend Your Brand

API Serpent — Thu, 16 Jul 2026 08:43:41 +0000

Building an AI Citation Tracker in Python

The overlap between Google top-10 rankings and
AI Overview citations dropped from 76% to 38%
in one year (Ahrefs, 2026).

This means ranking well on Google no longer
guarantees appearing in AI answers above your
result. You need to track both signals separately.

This tutorial shows how to build a tracker that
checks all four major AI engines simultaneously.

Why four engines?

Each uses a completely different search index:

Engine	Index used	Daily queries
ChatGPT	Bing	~2.5B prompts
Claude	Brave Search	Enterprise-heavy
Gemini	Google	~2B+
Perplexity	Proprietary	780M/month

Empirical overlap between citations: below 20%.

Monitoring one engine captures roughly 1/5th
of the full AI recommendation landscape.

Setup

bash
pip install requests python-dotenv

python
# .env
SERPENT_API_KEY=your_key_here

The tracker

python
import os
import requests
from dataclasses import dataclass
from typing import Optional
from dotenv import load_dotenv

load_dotenv()

@dataclass
class Citation:
    engine: str
    url: str
    position: int
    cited_text: Optional[str]

@dataclass  
class VisibilityReport:
    keyword: str
    citations: list[Citation]
    scores: dict[str, int]
    combined_score: int

class AICitationTracker:
    BASE_URL = "https://apiserpent.com/api"
    ENGINES = ["chatgpt", "claude", "gemini", "perplexity"]

    def __init__(self):
        self.api_key = os.getenv("SERPENT_API_KEY")
        self.session = requests.Session()
        self.session.headers.update({"X-API-Key": self.api_key})

    def check_visibility(
        self, 
        keyword: str,
        engines: list = None
    ) -> VisibilityReport:
        """
        Check brand citations across AI engines.
        Returns structured visibility data.
        """
        engines = engines or self.ENGINES

        response = self.session.get(
            f"{self.BASE_URL}/ai/rank",
            params={
                "keyword": keyword,
                "engines": ",".join(engines)
            },
            timeout=30
        )
        response.raise_for_status()
        data = response.json()

        citations = []
        scores = {}

        for engine, result in data["results"].items():
            scores[engine] = result.get("visibility_score", 0)
            for cite in result.get("citations", []):
                citations.append(Citation(
                    engine=engine,
                    url=cite["url"],
                    position=cite["position"],
                    cited_text=cite.get("cited_text")
                ))

        return VisibilityReport(
            keyword=keyword,
            citations=citations,
            scores=scores,
            combined_score=data.get("combined_visibility_score", 0)
        )

    def track_keywords(self, keywords: list[str]) -> dict:
        """Track multiple keywords and return summary."""
        results = {}
        for kw in keywords:
            report = self.check_visibility(kw)
            results[kw] = {
                "combined_score": report.combined_score,
                "scores_by_engine": report.scores,
                "total_citations": len(report.citations),
                "engines_citing": list({c.engine for c in report.citations})
            }
        return results

# Usage
tracker = AICitationTracker()

# Single keyword check
report = tracker.check_visibility("best SERP API for developers")

print(f"Combined visibility score: {report.combined_score}/100\n")
for engine, score in report.scores.items():
    print(f"{engine}: {score}/100")
    engine_cites = [c for c in report.citations if c.engine == engine]
    for cite in engine_cites:
        print(f"  → pos {cite.position}: {cite.url}")

# Multiple keywords
keywords = [
    "best rank tracking API",
    "google SERP API Python",
    "cheapest search API"
]
summary = tracker.track_keywords(keywords)
for kw, data in summary.items():
    print(f"\n{kw}")
    print(f"  Score: {data['combined_score']}/100")
    print(f"  Cited by: {', '.join(data['engines_citing']) or 'none'}")

Understanding the output

The visibility_score (0-100) per engine is a
composite of:

Citation presence (yes/no)
Position of citation vs competitors
Frequency across similar queries
Source authority of the cited URL

Track this weekly. A score dropping 10+ points
in a week means a competitor page overtook yours
in that engine's citations.

10 free searches to start

API key at apiserpent.com —
no card required. Pay-as-you-go from $1.22/1K
(Gemini) to $11.11/1K (Perplexity) at default tier.

Drop questions below — happy to discuss
the architecture.

How to build a multi-engine AI citation tracker in Python (under 30 lines)

API Serpent — Wed, 15 Jul 2026 13:54:45 +0000

Most rank trackers tell you "position 3."

In 2026, that's not enough information.
Google AI Overviews now appear on ~55% of
searches and push organic results down
200-400px before users see them.

"Position 1" can be below the fold.

This tutorial shows how to build a tracker
that returns both rank position AND pixel
coordinates of every SERP element — plus
AI citation visibility across ChatGPT,
Claude, Gemini, and Perplexity.

Using Serpent API (10 free searches, no card:
apiserpent.com).

import requests
import json

API_KEY = "your_serpent_api_key"
BASE_URL = "https://apiserpent.com/api"

def check_ai_visibility(keyword: str, engines: list = None) -> dict:
    """
    Check if your brand appears in AI engine citations
    across ChatGPT, Claude, Gemini, and Perplexity.
    """
    if engines is None:
        engines = ["chatgpt", "claude", "gemini", "perplexity"]

    response = requests.get(
        f"{BASE_URL}/ai/rank",
        params={
            "keyword": keyword,
            "engines": ",".join(engines)
        },
        headers={"X-API-Key": API_KEY},
        timeout=30
    )
    response.raise_for_status()
    return response.json()

def check_serp_position(keyword: str, engine: str = "google") -> dict:
    """
    Get rank position AND pixel coordinates 
    of every SERP element.
    """
    response = requests.get(
        f"{BASE_URL}/search",
        params={"q": keyword, "engine": engine},
        headers={"X-API-Key": API_KEY},
        timeout=15
    )
    response.raise_for_status()
    data = response.json()

    # Extract pixel positions — unique feature
    positions = []
    for result in data.get("organic_results", []):
        positions.append({
            "rank": result["position"],
            "url": result["link"],
            "pixel_x": result.get("pixel_position", {}).get("x"),
            "pixel_y": result.get("pixel_position", {}).get("y"),
            "above_fold": result.get("pixel_position", {}).get("y", 999) < 600
        })
    return positions

# Example usage
if __name__ == "__main__":
    keyword = "best project management API"

    # Check AI citations
    ai_data = check_ai_visibility(keyword)
    for engine, data in ai_data["results"].items():
        score = data.get("visibility_score", 0)
        citations = len(data.get("citations", []))
        print(f"{engine}: score={score}, citations={citations}")

    # Check SERP with pixel positions
    serp = check_serp_position(keyword)
    for item in serp[:3]:
        fold_status = "above fold" if item["above_fold"] else "below fold"
        print(f"Rank {item['rank']}: {item['url']} → {fold_status} (y={item['pixel_y']}px)")

How to Build a Real-Time Rank Tracker in Node.js (Without Getting IP Banned)

API Serpent — Mon, 13 Jul 2026 07:05:44 +0000

If you are managing search engine optimization for a platform, you know that keeping an eye on where your pages rank is critical. Native tools like Google Search Console are fantastic for analyzing post-click impressions and exact search queries for your blog posts, but they suffer from a major limitation: data delay. They don't give you real-time, on-demand visibility of the live search results or competitor movements.

To get real-time data, you have to build your own rank tracker. But scraping search results programmatically in 2026 usually leads straight to proxy hell, headless browser memory leaks, and endless CAPTCHA loops.

Today, we are going to build a lightweight, real-time programmatic rank tracker in Node.js. Instead of managing our own Puppeteer clusters and residential proxies, we are going to abstract all that headache away using a REST endpoint that returns structured JSON.

Prerequisites
Node.js installed on your machine.

Basic knowledge of JavaScript and HTTP requests.

An API key from API Serpent (we will use this to bypass the proxy/CAPTCHA issues—they offer a highly cost-effective tier at $0.03/10k pages).

Step 1: Project Setup
First, initialize a new Node.js project and install axios to handle our HTTP requests.

mkdir rank-tracker
cd rank-tracker
npm init -y
npm install axios

Step 2: Writing the Scraping Logic
Create a file named tracker.js. We will set up a function that takes our target keyword and our domain, pings the API, and parses the JSON response to find exactly where we rank.

const axios = require('axios');

// Configuration
const API_KEY = 'YOUR_API_SERPENT_KEY';
const TARGET_DOMAIN = 'yourdomain.com';
const SEARCH_QUERY = 'best seamless innerwear';

async function checkRanking() {
    console.log(`🔍 Searching Google for: "${SEARCH_QUERY}"...`);

    try {
        // Ping the API Serpent endpoint
        const response = await axios.get('https://api.apiserpent.com/search', {
            params: {
                api_key: API_KEY,
                engine: 'google',
                q: SEARCH_QUERY,
                geo: 'us', // Localize the search
                num: 100 // Fetch top 100 results
            }
        });

        const organicResults = response.data.organic_results;

        // Find our domain in the results
        const ranking = organicResults.find(result => result.link.includes(TARGET_DOMAIN));

        if (ranking) {
            console.log(`✅ Success! ${TARGET_DOMAIN} is currently ranking at position: #${ranking.position}`);
            console.log(`🔗 URL: ${ranking.link}`);
        } else {
            console.log(`❌ ${TARGET_DOMAIN} is not ranking in the top 100 results for this query.`);
        }

    } catch (error) {
        console.error('Error fetching SERP data:', error.message);
    }
}

checkRanking();

Step 3: Run the Tracker
Execute your script in the terminal:

node tracker.js

Expected Output:

🔍 Searching Google for: "best seamless innerwear"...
✅ Success! yourdomain.com is currently ranking at position: #4
🔗 URL: https://yourdomain.com/blog/seamless-guide

Why This Architecture Wins
By routing the request through a dedicated SERP API:

Zero Proxy Maintenance: You don't have to buy or rotate residential IPs.

No DOM Parsing: Search engines change their HTML structure constantly. By requesting JSON, your code won't break when Google updates a div class.

Scalability: You can easily wrap this function in a cron job, pull keywords from a database, and run thousands of checks a day without hitting rate limits.

Next Steps
From here, you can easily pipe this JSON data into a database like PostgreSQL or MongoDB, and attach a simple frontend dashboard to visualize your keyword movements over time. You can also explore the API's newer features, like native AI model citation tracking, to see if your brand is being mentioned in AI overviews.

Disclosure: I am the creator of API Serpent. We built this infrastructure because we were tired of overpaying legacy tools for basic search data. If you are building programmatic SEO tools or need reliable search data pipelines, give it a spin and let me know your thoughts!

I have built the Cheapest Serp API in the World - That's Serpent API

API Serpent — Fri, 10 Jul 2026 10:32:27 +0000

Serpent API exists for one reason: SERP data shouldn't cost more than the team analyzing it.

For a decade, the SERP API market was dominated by providers charging $5–50 per 1,000 searches, locked behind enterprise contracts, monthly minimums, and sales calls. A single SEO agency tracking a few thousand keywords a day was burning through $1,500–$5,000 per month on raw search data alone — money that should have funded talent, content, and client outcomes, not API bills.

We're a team of marketers who lived this pain every month. So we built the infrastructure ourselves. Today, Serpent API delivers the same Google, Bing, Yahoo!, and DuckDuckGo data — at a fraction of the cost, with no contracts, no minimums, and no enterprise sales calls required.