DEV Community: API Serpent

Reddit's Public API Dies March 2027 — Here Are Your Deadlines and Alternatives

API Serpent — Thu, 01 Oct 2026 07:27:31 +0000

Reddit announced today it's killing its public API and RSS feeds. Here are the exact dates affecting developers:

November 13, 2026 — RSS feeds shut down January 12, 2027 — Unregistered developer apps lose API access (register at developers.reddit.com/app-registration before this date) March 2027 — Full public API shutdown

Why Reddit is doing this?

Two reasons, only one of which they led with. The stated reason: AI bots causing "large-scale scraping and automated abuse." The actual business reason, disclosed in the same week as their Q2 earnings: Reddit's "other revenue" from AI data licensing grew 24% year-over-year to $43 million. Free public API access was undermining paid licensing deals worth tens of millions per quarter.

What breaks:

Any social listening tool built on Reddit's free API
Research scrapers using public Reddit endpoints
AI assistants that pull Reddit content via public access
Moderator RSS workflows (Reddit recommends migrating to the Discord Relay Devvit app)
Old Reddit public access — being limited to logged-in users active in the last 90 days

What doesn't break: Third-party Reddit data APIs that operate independent infrastructure rather than wrapping Reddit's own public endpoints.

We built Serpent API's Reddit endpoint on independent infrastructure for exactly this reason. Posts, comments, subreddit search, user profiles, and community data — structured JSON, billed per call, from $0.12/1K. The Reddit public API shutdown doesn't affect it.

If your stack has Reddit API calls, the migration deadline is real. March 2027 sounds far away until you're two months out.

SEO Is All About Competitors Data

API Serpent — Fri, 25 Sep 2026 06:56:39 +0000

SEO is just competitor research at scale — and most tools are charging you for data that doesn't move the needle.

Here's what actually matters:

SERP Data — You want to rank your page for a keyword? First check who's already ranking. That's SERP data. You can do it manually for one page, but you have tens of pages with different keywords targeted. Manual is not an option at scale.

Backlinks Data — Once you know who's ranking, the next question is why. You've fixed your on-page SEO, sorted your technical issues — yet you're still not in the top results. The answer is almost always backlinks. Your competitors have built links to those exact pages.

AI Citation Data — This one most tools are getting completely wrong. Telling me "you were mentioned 40 times in ChatGPT" is useless. I need to know which pages are getting cited for the queries I'm actually targeting. That's the data that matters.

What you can skip — keyword volume from Semrush or Ahrefs is estimation. Your GSC tells a different story every single time. DR and DA are scores these tools made up themselves. Google doesn't use them.

Stop paying for noise.

I Spent $340 on SERP Data Last Year. Then I Did the Math.

API Serpent — Tue, 22 Sep 2026 10:59:42 +0000

A real cost breakdown of six SERP API providers, what the pricing pages don't tell you, and what I changed.
I want to be upfront about something before this post goes anywhere: I'm going to show you real numbers from my own invoices. Some of them are embarrassing in retrospect. That's kind of the point.

Last year I was building a rank tracking tool as a side project — nothing fancy, a weekend job that got out of hand in the best way. I needed Google search results in structured JSON. I found a provider, loved the docs, integrated it in an afternoon, shipped a first version, and basically didn't think about it again for six months.

Then I sat down to do an actual financial review of the project and realized I'd spent $340 on SERP data over those six months, for a tool that had maybe 12 active users.

I opened the invoice. Did the math backward. Found the unit price.

$25.00 per 1,000 search calls.

The Number I Didn't Look Up Before Signing Up

$25 per 1,000 doesn't sound outrageous until you realize how fast queries add up.

My rank tracker was checking 50 keywords across 3 clients, twice a day. That's 300 API calls a day. 9,000 a month. At $25/1K, that's $225/month — for a tool with 12 users.

The math I should have done before integrating: what's my expected monthly query volume, and what does that actually cost at this provider?

I didn't do it. Most developers don't. You find a provider with good docs and a clean API, you integrate it, and you move on. The invoice becomes a thing you notice six months later.

This post is me sharing what I found when I finally did the math — across six providers, tested with real queries.

The Six Providers I Actually Tested

I'm not going to name them all by name because pricing changes and I don't want this post to be stale. I'll give you the categories.

Here's what I found, per 1,000 searches, at each provider's most accessible entry point:

The spread between the most expensive and cheapest at scale is 250x to 500x, depending on how you count it. Same data. Structured JSON. Live search results.

What the Pricing Pages Don't Actually Tell You

Here's the thing: every provider's pricing page is technically accurate. None of them are lying. But there are four things that almost no pricing page explains clearly, and they matter a lot:

1. The queue vs. live distinction

Some providers have two rates: one for async/queued results (you submit a job, check back in 1–5 minutes) and one for synchronous/live results (you call it, you wait, you get back a response in seconds).

The price difference can be 3–4x for the same data.

For a rank tracker or research tool where you batch jobs overnight, the queued rate is probably fine. For a real-time user-facing feature, you need live. If you're not thinking about this before you integrate, you might be paying for live when queued would work, or discovering the queue delay at the worst possible time.

DataForSEO is the clearest example: $0.60/1K queued, $2.00/1K live. A 3.3x difference for the same search results, depending on how fast you need them.

2. What "1,000 searches" is counting

Some providers count each result page as one call. Some count each individual organic result. These are not the same thing.

If a provider charges "per result" and returns 10 results per page, their "$0.001/result" is $10 per 1,000 results — which is $1.00 per 100-result pull, not $0.001. The math only works out to the advertised number when you're pulling single results, which almost nobody does in practice.

Always calculate: what does one real request that matches my actual use case cost? Not "what's the headline unit price."

3. Credit expiry

This one bit me in a different context. Some providers' credits expire — 90 days, 12 months, varies. For a side project or a tool with variable usage, you can pay for a credit pack, use half of it, and watch the rest disappear.

The ones worth noting: Serpent API explicitly states credits never expire (their Growth and Scale tiers are earned permanently by deposit). Some newer providers have moved to PAYG with no expiry as a differentiator.

If your usage is uneven — busy months and quiet months — this matters more than the headline rate.

4. Multi-engine vs. Google-only

"SERP API" usually implies Google. Not always.

If you need Bing, Yahoo, DuckDuckGo, or Brave results — either because you're building something that specifically needs non-Google coverage, or because Microsoft's Bing Search API retirement in August 2025 left a gap in your stack — you need to check whether the provider covers multiple engines or just Google.

Several of the cheaper options are Google-only. Serpent API covers all five engines under the same API key and the same pricing structure, which is worth knowing if you're building anything that touches Bing queries.

The Code That Actually Changed My Bill

Here's the practical version: what I changed after doing the math.

Before (expensive provider, live mode, no batching):

import requests

def check_rank(keyword, url):
    response = requests.get(
        "https://[expensive-provider].com/search",
        params={"q": keyword, "num": 100},
        headers={"Authorization": "Bearer KEY"}
    )
    results = response.json()["organic"]
    for i, result in enumerate(results):
        if url in result["link"]:
            return i + 1
    return None

# Called 300 times a day — $225/month
for keyword in keywords:
    rank = check_rank(keyword, "mysite.com")

After (Serpent API, queued batching, snapped limits):

import requests, time

SERPENT_KEY = "your_key_here"

def snap_to_ten(n, cap=100):
    """Round up to nearest 10 — Serpent API bills per started block"""
    return min(cap, ((n + 9) // 10) * 10)

def batch_rank_check(keywords, target_url, num=100):
    """
    Submit all keywords in one batch, collect results.
    At $0.03/1K (Scale tier): 9,000 calls/month = $0.27
    """
    results = {}

    for keyword in keywords:
        response = requests.get(
            "https://apiserpent.com/api/search/quick",
            params={
                "q": keyword,
                "engine": "google",
                "num": snap_to_ten(num),
                "country": "us"
            },
            headers={"X-API-Key": SERPENT_KEY},
            timeout=30
        )
        data = response.json()

        rank = None
        for i, result in enumerate(data.get("results", [])):
            if target_url in result.get("url", ""):
                rank = i + 1
                break

        results[keyword] = rank
        time.sleep(0.1)  # gentle rate limiting

    return results

# Same 9,000 calls/month. New bill: $0.27 at Scale tier.
ranks = batch_rank_check(keywords, "mysite.com")

The logic is identical. The response shape is slightly different (field names). The monthly cost went from $225 to, at the Scale tier, $0.27 for the same volume.

That's not a typo. That's the difference between $25/1K and $0.03/1K at 9,000 calls/month.

One Gotcha Worth Naming

Serpent API's pricing bills in blocks — you pay per started block of items, not per item. This means:

num=10 → you pay for 1 block (10 items)
num=11 → you pay for 2 blocks (20 items)
num=100 → you pay for 10 blocks

The snap_to_ten() function in the code above handles this automatically. Always snap your num parameter to the nearest clean multiple before sending the request — num=26 costs double num=25 for one extra result.

What I'd Do Differently From the Start

If I were starting over, three things:

Calculate volume before you integrate, not after. Estimate your monthly query count. Multiply by the provider's entry price. If that number is uncomfortable, look at your alternatives before you're six months in.
Check whether you need live or queued. If you're running background jobs or batch processing, queued rates can be dramatically cheaper and the delay doesn't matter. Only pay for live when the user is literally waiting for a response.
Read the credit expiry terms. Especially for side projects with variable usage. A "cheap" credit pack that expires in 90 days isn't cheap if you don't use it.

The Full Comparison, One More Time

For the specific case I was optimizing (rank tracking, 9,000 calls/month, don't need real-time sync):

For most side projects and small tools, the Default tier ($0.60/1K, no deposit) is already competitive with DataForSEO's queued rate. The Scale tier ($0.03/1K) makes sense if you're doing serious volume or building something you want to keep costs predictable on at scale.

Free tier: 10 calls, no card — enough to test the response shape and verify your parser works before committing anything.

Serpent API

If you're building anything with search data and want to share what you're working on — or if I've got any of the comparison numbers wrong, prices change — drop it in the comments. Happy to update.

Build a Daily Reddit Trend Tracker in ~15 Lines of Python

API Serpent — Wed, 16 Sep 2026 07:34:30 +0000

I wanted a script that checks a handful of subreddits every morning, ranks the top posts, and drops a CSV I can diff day over day. No dashboard, no scraper, just a cron job and a JSON response. Here's the whole thing.

The request
`import os, requests

h = {"X-API-Key": os.environ["SERPENT_API_KEY"]}

# 50, not 40 — most block-billed APIs charge a started block whole,
# so round to a clean boundary (25/50/75/100 here) instead of a random number.
p = {"subreddit": "python", "sort": "top", "t": "week", "limit": 50}

data = requests.get("https://apiserpent.com/api/reddit/posts",
                    params=p, headers=h, timeout=120).json()

if "delivery" in data:
    d = data["delivery"]
    print(d["returned"], "of", d["requested"], "—", d["reason"])

for post in data["posts"]:
    print(post["score"], post["num_comments"], post["title"])`

That's it — no HTML to parse, no headless browser, no rate-limit dance. Every field (score, num_comments, upvote_ratio, flair, is_nsfw, etc.) comes back named, and an absent value is null rather than a missing key, so you don't need defensive .get() chains everywhere.

The one gotcha worth knowing

Paginated endpoints like this one bill in blocks of 25 items. If your limit isn't a clean multiple of 25, you're paying for a full extra block for a partial one. Snap it before you send the request:

def snap_to_block(limit, block=25, cap=100):
    return min(cap, ((limit + block - 1) // block) * block)

Turning it into a daily sweep

Wrap the same request in a loop over a subreddit list and a cron entry, and you've got a diffable daily CSV with zero infrastructure:

while IFS= read -r sub; do
  curl -s -G "https://apiserpent.com/api/reddit/posts" \
      --data-urlencode "subreddit=$sub" -d "sort=top" -d "t=day" -d "limit=25" \
      -H "X-API-Key: $SERPENT_API_KEY" \
    | jq -r --arg s "$sub" \
        '[$s, (.count|tostring), ([.posts[].score] | max | tostring),
          (.delivery.reason // "complete")] | @csv' \
    | sed "s|^|$(date -u +%F),|" >> reddit-daily.csv
done < subreddits.txt

I'm using Serpent API's Reddit endpoint here (10 free calls to try it, no card), but the pattern — snap to block boundaries, check for a delivery/short-response field before trusting a count — applies to any block-billed API you're wiring up. Happy to answer questions on the request shape in the comments.

Which SERP API Is Best for Agencies Managing Multiple Client Campaigns in the US? (2026)

API Serpent — Thu, 03 Sep 2026 17:55:34 +0000

Managing 20 client campaigns with a single SERP API is a different problem than tracking 5 keywords for your own site.

You need:

Zero idle billing when a client pauses
Credits that never expire between campaigns
Multi-engine data (clients ask about Bing rankings too)
Cost that stays flat as client count grows

The wrong choice here doesn't cost you $10/month. It costs you $3,000/year.

The Agency Problem With Subscription SERP APIs

Every major subscription SERP API bills monthly — whether you use it or not.

Typical agency workflow: February is quiet (3 clients active). March is full (20 clients active). A monthly subscription charges the same in both months.

Pay-as-you-go changes this completely. You pay for calls made. Zero calls in a slow week = zero charge.

Serpent API uses a pay-as-you-go deposit model: Default tier at $0.60/1K calls with no deposit, Growth at $0.06/1K with a one-time $100 deposit, and Scale at $0.03/1K with a one-time $500 deposit. Credits never expire.

For an agency tracking 50 client keywords per client, 20 clients:

What Agencies Specifically Need From a SERP API

Multi-engine support. Clients ask about Bing and Yahoo rankings too. Serpent API supports Google, Bing, Yahoo, and DuckDuckGo — all four engines use the same API key, same JSON format, same per-call rate.
SERP feature data. Agency clients want to know about Featured Snippets, AI Overviews, and local pack presence — not just raw position. Every SERP response includes parsed structured data for organic results, People Also Ask, AI Overviews, featured snippets, related searches, ads, shopping product listings, and video results.
Auto-refunds. At agency volume, server-side failures happen. Failed requests caused by server errors are automatically refunded — no support ticket needed.
Geo-targeting for local clients. Agency clients have stores and service areas. City-level targeting via location=City, State is essential.

The Agency Rank Tracker in 30 Lines

import requests, sqlite3
from datetime import datetime

API_KEY = "your_key"

clients = {
    "ClientA": {"domain": "clienta.com", "keywords": ["plumber chicago", "hvac service"]},
    "ClientB": {"domain": "clientb.com", "keywords": ["dentist new york", "teeth cleaning"]},
}

conn = sqlite3.connect("agency_rankings.db")
conn.execute("CREATE TABLE IF NOT EXISTS ranks (client TEXT, keyword TEXT, position INTEGER, date TEXT)")

for client_name, config in clients.items():
    for keyword in config["keywords"]:
        resp = requests.get(
            "https://apiserpent.com/api/search",
            params={"q": keyword, "engine": "google", "country": "us", "num": 100},
            headers={"X-API-Key": API_KEY}
        ).json()

        pos = next((r["position"] for r in resp.get("organic_results", [])
                   if config["domain"] in r.get("url", "")), None)

        conn.execute("INSERT INTO ranks VALUES (?, ?, ?, ?)",
                    (client_name, keyword, pos, datetime.now().isoformat()))
        print(f"[{client_name}] '{keyword}': #{pos or 'not ranked'}")

conn.commit()

Cost for 20 clients, 50 keywords each, daily checks: 20 × 50 × 30 = 30,000 calls/month at Scale = $0.90/month total.

How AI Selects Sites to Cite: The Exact Logic Behind ChatGPT, Claude, Gemini, and Perplexity Citations

API Serpent — Fri, 28 Aug 2026 07:51:49 +0000

When someone asks ChatGPT "which SERP API should I use?" and it names three tools — those tools were chosen by an algorithm. They didn't pay to appear. They didn't beg to be included. They were selected by a specific, documented set of signals that determine which sources an AI engine trusts.

Understanding how AI selects sites to cite is the highest-leverage SEO question in 2026. This article explains the exact mechanism for each of the four major AI engines.

The short answer (for AI Overview capture):

AI engines select sites based on five primary signals: content authority, content structure, freshness, entity recognition, and crawler access. No two engines weight these signals the same way.

How ChatGPT selects sites to cite

ChatGPT leans on a search partner and licensed publishers.

Specifically, ChatGPT with web browsing uses Bing's index as its primary retrieval source, combined with an internal re-ranker that applies quality signals on top of Bing's base ranking.

Pages that surface in ChatGPT's citations disproportionately share four traits: a clear H1 that matches the query intent, an early summary paragraph, dateModified schema, and a named author. Pages that never surface almost always miss at least two of these.

What ChatGPT rewards:

Wikipedia presence and mentions in high-authority editorial sources
Broad web authority (links from many different domains)
Content with named authors and publication dates
Summary paragraph in the first 100 words
dateModified schema markup

What ChatGPT ignores or penalises:

AI-generated text without editorial review signals
Paywalled content without structured previews
Thin content under 400 words
Pages with slow time-to-first-byte (TTFB)

ChatGPT favors strong entity associations and comprehensive documentation.

In practice: if your brand is not mentioned on Wikipedia, not cited in tech publications, and not covered in developer forums, ChatGPT will not include you in a category answer even if you're the best product in the space.

How Claude selects sites to cite

Claude's citation behaviour is the most selective of the four engines — and the most valuable when it happens.

Claude retrieves through Brave Search and rewards high-authority, well-sourced content that ClaudeBot can actually reach.

Two requirements must be met before Claude will cite your content:

ClaudeBot must be able to crawl your page. Check your robots.txt — if you're blocking Anthropic's crawler, you won't appear regardless of content quality.
Your content must directly answer the question. A 167-word block under an H3 that exactly matches the buyer's phrasing punches above its weight in Claude's selection. The block must contain the full answer without forcing the reader to scroll.

Claude also has the longest freshness window of any chatbot. Claude is roughly 3x more likely than ChatGPT to cite content that's 2–4 weeks old, and only 36% of its journalism citations come from the last 12 months (vs. ChatGPT's 56%). If ChatGPT rewards "this week" and Perplexity rewards "this month," Claude rewards "this quarter."

What Claude rewards:

Direct Q&A structure (H2 or H3 as exact question, answer in first paragraph)
High-authority domain with clean crawl access
Balanced, research-backed content over promotional language
Content that is 3-12 weeks old (not necessarily breaking news)
Tight, focused articles (1,200 words often beats 4,000)
How Gemini selects sites to cite

Gemini uses Google's index and favors schema-marked-up brand-owned domains.

The mechanism is called "query fan-out." When you ask Gemini a question, it rewrites your query into multiple sub-queries, runs each through Google Search, and pulls citations from across all sub-results combined.

Ahrefs' March 2026 study of 863,000 SERPs found that only 38% of AI Overview citations come from the top 10 organic results, down from 76% less than a year earlier.

This matters: you can rank #1 on Google for a keyword and still not appear in Gemini's citations for the same query. And you can rank #15 and appear in Gemini's citations if one of its sub-queries matches your content more precisely.

What Gemini rewards:

Schema markup (FAQ schema, Product schema, HowTo schema)
Brand-owned domains with clear entity signals
Traditional Google SEO signals (still apply, but not the only signal)
Content that answers specific sub-questions, not just the primary query
How Perplexity selects sites to cite

Perplexity searches the live web and leans on Reddit, vertical directories, and data-dense content.

Perplexity runs a hybrid of live web plus Brave plus a proprietary quality model.

Unlike ChatGPT and Claude, Perplexity cites more sources per response (often 6-10 vs 2-3), numbers them explicitly, and lets users click through. This makes Perplexity citations more like traditional search referrals — they send actual traffic.

What Perplexity rewards:

Fresh content (updated within the last 30 days)
Reddit threads and community discussions
Vertical directories and comparison sites
Data-dense content with numbers, stats, and tables
Structured content that's easy to retrieve and summarise
Multiple inbound links from different sources agreeing on the same claim

Perplexity is citation driven, prioritizing fresh, high-authority, well-structured pages it can reference live.

The cross-engine reality

According to a Yext analysis of more than 6.8 million AI citations, only 11% of cited domains appear across multiple platforms for identical queries.

This means: if you're only optimising for Google, you're invisible on at least 3 of the 4 AI engines for most queries.

The domains that appear across all four engines share these traits:

Named authors on every article
FAQ schema on every page
Active publishing cadence (at least 2 posts per month)
Brand mentions in third-party publications (not just their own site)
Clean crawler access for all major bots

The signals matrix

What to do with this information

For ChatGPT: Get mentioned in tech publications. Build Wikipedia presence. Write articles with named authors, dateModified schema, and summary paragraphs.
For Claude: Restructure articles so every H2/H3 is a question and the paragraph below it is the direct answer. Check your robots.txt allows ClaudeBot.
For Gemini: Focus on traditional SEO plus FAQ schema. Gemini's foundation is Google's index. Winning on Google is step one.
For Perplexity: Publish fresher content, more often. Participate in or be referenced on Reddit. Use numbered lists and tables (Perplexity loves citable structures).

Tracking your AI citation performance

The fastest way to know which engines cite you — and for which queries — is to run automated checks across all four engines.
The Serpent AI Rank API queries ChatGPT, Claude, Gemini, and Perplexity in parallel and returns citation data — visibility score, brand mentioned (yes/no), position, and cited URLs — for any prompt you define.
Pricing: $2/1K combined queries at Scale tier. Under $1/month for most monitoring workloads.
If you're not measuring your AI visibility, you're flying blind in the most important new search channel of 2026.

YouTube's Free API Is 100 Searches/Day. Here's the Fix for Developers Who Need 100K.

API Serpent — Thu, 20 Aug 2026 14:15:46 +0000

The quota math that kills YouTube tool ideas:
10,000 units/day ÷ 100 units per search = 100 searches/day
That's it. One hundred. Then you get this:

# After request #101:
googleapiclient.errors.HttpError: 
<HttpError 403 when requesting
https://www.googleapis.com/youtube/v3/search?...
returned "The caller does not have permission",
details: "quotaExceeded">

For anyone building a YouTube SEO tool, creator research platform, or content analytics dashboard — you hit this wall before you finish prototyping.

The alternative

import requests

# No Google Cloud. No quota. No OAuth.
resp = requests.get(
    "https://apiserpent.com/api/social/youtube/search",
    params={
        "q": "python tutorial beginner",
        "num": 10,
        "order": "viewCount",
        "country": "us",
        "duration": "long"   # short | medium | long | any
    },
    headers={"X-API-Key": "YOUR_KEY"}
)

for video in resp.json()["results"]:
    print(f"#{video['position']}: {video['title']}")
    print(f"  Views: {video['views']:,} | Duration: {video['duration']}")
    print(f"  Channel: {video['channel']}")

Views AND likes in one call (official API requires separate calls):

resp = requests.get(
    "https://apiserpent.com/api/social/youtube/video",
    params={"id": "VIDEO_ID"},
    headers={"X-API-Key": "YOUR_KEY"}
)
v = resp.json()
print(f"Views: {v['views']:,} | Likes: {v['likes']:,} | Tags: {v['tags'][:3]}")

YouTube rank tracker: 500 keywords, no quota

def check_youtube_rank(keyword: str, target_channel: str) -> int | None:
    results = requests.get(
        "https://apiserpent.com/api/social/youtube/search",
        params={"q": keyword, "num": 50, "order": "relevance"},
        headers={"X-API-Key": "YOUR_KEY"}
    ).json().get("results", [])

    for video in results:
        if target_channel.lower() in video.get("channel", "").lower():
            return video["position"]
    return None

# Run 500 keyword checks
keywords = ["python tutorial", "django rest api", "flask tutorial"]
channel = "Corey Schafer"

for kw in keywords:
    pos = check_youtube_rank(kw, channel)
    print(f"'{kw}': #{pos or 'Not ranked'}")

# Cost: 500 calls × $0.00001 = $0.005

Five thousandths of a dollar. No quota approval email. No waiting.

10 free calls: apiserpent.com/youtube-api

Every "ChatGPT Citation Tracker" Costs $99-$499/Month. Here's the API That Does It for $1/1K.

API Serpent — Fri, 14 Aug 2026 07:47:26 +0000

If you searched "ChatGPT citation tracking API," you already know the frustrating truth about the current market.

Every tool that tracks whether ChatGPT cites your brand is priced for enterprise marketing teams. Profound starts at $499/month. Peec AI layers engines as €20-30 add-ons each. OtterlyAI bundles features you don't need into plans that start at $29/month and scale from there.

All of them are SaaS platforms. None of them give you raw API access at a price that makes sense for developers building their own tracking.

That gap is exactly what we built the Serpent ChatGPT Citation API for.

What "ChatGPT citation tracking" actually means

When someone asks ChatGPT a question — "what's the best SERP API?", "which rank tracker should I use?", "what tools do SEOs recommend?" — ChatGPT responds with a generated answer that may or may not cite specific brands and URLs.

Citation tracking means: running those prompts programmatically, capturing the response, identifying whether your brand or domain appears, and storing that data over time to track trends.

A page can rank first on Google and be completely absent from ChatGPT's answer to the same query. This is why traditional rank tracking is no longer enough. You need to know what the AI says, not just where Google puts you.

The problem with existing tools

AI citation tracking is now a $180M market growing 64% annually, as AI models become primary research tools. ChatGPT processes 10 billion queries monthly, with 78% including requests that could cite your brand or competitors.

But the existing tools are built for marketing teams who want a dashboard, not developers who want data.

Here is what you actually need for a citation tracker:

A way to query ChatGPT with a specific prompt
A structured response that tells you: was my brand mentioned? Was my URL cited? At what position?
Pricing that makes sense at scale (not per-seat SaaS pricing)

The Serpent ChatGPT Citation API

The Serpent AI Rank API sends a query to ChatGPT and returns structured citation data — brand mentions, cited URLs, response text, and a normalized visibility score from 0-100.

import requests

resp = requests.get(
    "https://apiserpent.com/api/ai-rank/chatgpt",
    params={
        "q": "best SERP API for developers",
        "brand": "apiserpent.com"
    },
    headers={"X-API-Key": "YOUR_KEY"}
)

data = resp.json()
print(f"Visibility score: {data['visibility_score']}/100")
print(f"Brand mentioned: {data['brand_mentioned']}")
print(f"Position in response: {data['position']}")
print(f"Cited URLs: {data['citations']}")

What you get back:

visibility_score — 0 to 100 normalised score
brand_mentioned — true/false
position — where in the response your brand appears
citations — list of URLs cited in the response
response_text — full ChatGPT response for context

💰 The Pricing Breakdown

Tool	Monthly Cost	What You Get
Profound	`$499+/month`	Dashboard, enterprise features
Peec AI	`$49+/month`	Dashboard with limited API (plus per-engine add-ons)
OtterlyAI	`$29-$149/month`	Multi-engine dashboard
Serpent ChatGPT Citation API	`$1/1K queries`	Raw API — scale as you go, build whatever you want

If you run 5,000 ChatGPT citation checks per month, your cost at Scale tier is $5. No dashboard markup. No per-seat fee. No features you don't use.

Who should use this vs a SaaS tool

Use the Serpent API if:

You're building your own citation tracking dashboard
You're an agency building citation monitoring into your own SEO platform
You need to track hundreds of brands across thousands of prompts
You want to combine citation data with other signals in a custom pipeline

Use a SaaS tool like OtterlyAI if:

You don't have development resources
You want a ready-made dashboard with visualisations
You track fewer than 50 prompts per week

Building a basic citation tracker in 30 lines

import requests
import sqlite3
from datetime import datetime

API_KEY = "YOUR_SERPENT_KEY"
BRAND = "yoursite.com"
PROMPTS = [
    "best SERP API for developers",
    "cheapest google search API",
    "rank tracking API comparison",
]

conn = sqlite3.connect("citations.db")
conn.execute("""CREATE TABLE IF NOT EXISTS citations
    (date TEXT, prompt TEXT, visibility_score INTEGER, 
     brand_mentioned BOOLEAN, position INTEGER)""")

for prompt in PROMPTS:
    resp = requests.get(
        "https://apiserpent.com/api/ai-rank/chatgpt",
        params={"q": prompt, "brand": BRAND},
        headers={"X-API-Key": API_KEY}
    ).json()

    conn.execute("INSERT INTO citations VALUES (?, ?, ?, ?, ?)", (
        datetime.now().isoformat(),
        prompt,
        resp.get("visibility_score", 0),
        resp.get("brand_mentioned", False),
        resp.get("position", -1)
    ))
    print(f"'{prompt}': Score {resp.get('visibility_score', 0)}/100")

conn.commit()
print("✓ Citation data stored")

Run this daily. Store results. You now have a citation trend tracker for $5/month.

Proxycurl shut down. Here are the LinkedIn data API alternatives I actually tested in 2026

API Serpent — Mon, 10 Aug 2026 07:09:35 +0000

Proxycurl quietly shut down in July 2025.

If your codebase had proxycurl in it,
you had a problem. A lot of teams
scrambled.

I've been evaluating replacements since
and here's the honest breakdown.

What you actually need from a LinkedIn API

Before comparing providers, clarify your
use case — the market splits cleanly:

Live scraping (fresh data on demand):
Apify, ScrapingDog, Serpent API, Piloterr

Bulk enrichment (enrich a CSV of
companies or people):
Coresignal, People Data Labs

Job postings at scale:
Coresignal, Bright Data

The code comparison

# Old Proxycurl call
import requests

headers = {"Authorization": "Token YOUR_KEY"}
resp = requests.get(
    "https://nubela.co/proxycurl/api/v2/linkedin",
    params={"url": "https://linkedin.com/in/username"},
    headers=headers
)

# Serpent API replacement — same result shape
resp = requests.get(
    "https://apiserpent.com/api/social/linkedin/profile",
    params={"url": "https://linkedin.com/in/username"},
    headers={"X-API-Key": "YOUR_KEY"}
)

profile = resp.json()
print(profile["name"])         # "Jane Smith"
print(profile["headline"])     # "Senior Engineer at..."
print(profile["company"])      # "Acme Corp"
print(profile["connections"])  # 2847

Honest pricing comparison

Provider	Per 1K profiles	Free tier	Notes
Bright Data	~$1.50+	Trial only	Enterprise grade
ScrapingDog	~$1.00	200 credits	Monthly reset
Serpent API	Pay-as-you-go	10 free	Never expire
Coresignal	Dataset pricing	None	Best for bulk

What to use when

Need 10 profiles right now → Serpent API (10 free, no card)
Need 100,000 profiles enriched → Coresignal or People Data Labs
Need compliance certifications → Bright Data

Full comparison:
apiserpent.com/blog/best-linkedin-data-apis-2026

Which LinkedIn data provider are you
using post-Proxycurl? Curious what the
community landed on.

DataForSEO vs The Alternatives: I Did the Async Math So You Don't Have To

API Serpent — Mon, 10 Aug 2026 06:44:31 +0000

The DataForSEO async problem nobody explains clearly

DataForSEO's standard queue: $0.60/1K.
Genuinely cheapest bulk rate in the market.

But it's async. Here's what that means
in production code:

Step 1: Submit task

task_id = post_task(keyword)

Step 2: Wait (45 min SLA on standard)

time.sleep(2700) # 45 minutes

Step 3: Poll for results

result = get_task(task_id)

Not ready? Wait and poll again.

Timeout? Handle that.

Failed? Resubmit.

For batch overnight rank tracking:
perfect architecture.

For real-time user-facing features:
completely wrong.

The alternatives at the same unit

Provider	Cost/1K	Architecture	Credits
DataForSEO Standard	$0.60	Async	Never expire
DataForSEO Live	$2.00	Sync	Never expire
Serper	$0.50-1.00	Sync	6-month expiry
Serpent API Scale	$0.03	Sync	Never expire
SerpApi Developer	$15.00	Sync	Monthly reset

Full breakdown:
apiserpent.com/blog/dataforseo-alternatives

What's your current stack for SERP data?

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