DEV Community: API Serpent

Building with eBay Data in 2026 — 6 Endpoints, 10 Markets, and the Billing Trap Nobody Warns You About

API Serpent — Tue, 13 Oct 2026 06:24:15 +0000

I want to start this post with the single most important thing to understand about eBay data APIs before you write a line of code.

A search request and a product record are not the same thing.

This sounds obvious, but it's responsible for more eBay API budget surprises than almost any other mistake. I'll explain the distinction, then show you how to use each of the six operations Serpent API's eBay endpoint exposes — with real code for each one.

The Data Model

eBay's public data has a natural hierarchy:

Search query
  └── Listing page (contains N listing cards)
        └── Listing card (title, price, condition, seller, item link)
              └── Item detail (images, specifics, availability, description)
                    └── Seller profile (identity, feedback score, positive rate)
                          └── Seller listings (inventory, page by page)
                          └── Seller feedback (buyer comments, ratings)
                          └── Product reviews (review text, rating, author)

Each layer is a separate API call. Each has its own rate. The mistake teams make is assuming that a "search" returns all of this. It doesn't — search returns the top level only. Enrichment requires additional calls per item.

This isn't a flaw — it's correct data architecture. You shouldn't pay for description data on items you're not interested in. But it means your cost model needs to account for every layer your application touches.

Setup

pip install requests python-dotenv

# .env
SERPENT_API_KEY=your_key_here

# ebay_client.py
import requests
import os

API_KEY = os.getenv("SERPENT_API_KEY")
BASE = "https://apiserpent.com/api/ebay"

HEADERS = {"X-API-Key": API_KEY}

def get(endpoint, params):
    r = requests.get(f"{BASE}{endpoint}", params=params, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

Operation 1 — Search Listings

GET /api/ebay/search returns a page of listings for a keyword on a specified marketplace.

def search_listings(query, marketplace="EBAY_US", locale="en-US", page=1):
    """
    Returns listing cards: title, price, condition,
    shipping, seller identity, item link.

    10 supported marketplace/locale pairs:
    EBAY_US/en-US  EBAY_GB/en-GB  EBAY_DE/de-DE
    EBAY_AU/en-AU  EBAY_IT/it-IT  EBAY_FR/fr-FR
    EBAY_CA/en-CA  EBAY_ES/es-ES  EBAY_NL/nl-NL
    EBAY_PL/pl-PL

    Rate: $0.40/1K calls at Default tier
    """
    return get("/search", {
        "q": query,
        "marketplace_id": marketplace,
        "locale": locale,
        "page": page
    })

# Example
results = search_listings("vintage camera", "EBAY_DE", "de-DE")
for listing in results.get("listings", []):
    print(listing["title"], listing["price"], listing["currency"])

What the response contains:

title — listing title as displayed
price / currency — displayed price in the marketplace's currency
condition — New, Used, Refurbished, For parts, etc.
shipping — shipping cost and type if displayed
seller — seller username
item_url — full item URL (use as item ID for subsequent calls)
item_id — eBay item ID

The page trap: a search returns one page. If eBay shows 48 listings on page 1, you get 48 rows. If 12 are sponsored/promoted and you filter them, you have 36. Cost is per page request, not per usable listing. Always measure yield on your actual keywords before budgeting at scale.

Operation 2 — Item Details

GET /api/ebay/item returns structured data for a specific item by ID or URL.

def get_item(item_id, include_description=False):
    """
    Returns price, images, item specifics, availability, seller.

    Add include_description=1 to get the full seller HTML description.
    Description calls: $1.50/1K (3.75x the standard rate).
    If description unavailable but core item exists, standard rate applies.

    Use include_description only when your pipeline needs it —
    most price monitoring workflows don't.
    """
    params = {"item_id": item_id}
    if include_description:
        params["include_description"] = 1
    return get("/item", params)

# Price check without description (standard rate)
item = get_item("v1|123456789012|0")
print(item["price"], item["currency"], item["condition"])

# With full description (description rate)
item_full = get_item("v1|123456789012|0", include_description=True)
print(item_full.get("description", "")[:200])

When to use include_description:

Product detail pages that show the seller's own copy
Condition verification that requires reading the description text
Content analysis pipelines

When NOT to use it:

Price monitoring (price is in the core item)
Stock tracking (availability is in the core item)
Search enrichment loops (you'd pay 3.75× for data you don't use)
Operation 3 — Seller Profile

GET /api/ebay/seller returns identity and reputation data for a seller username.

def get_seller_profile(seller_username):
    """
    Returns: seller identity, feedback score,
    positive feedback rate, profile link.

    Useful for: trust scoring, seller monitoring,
    marketplace research, fraud detection signals.
    Rate: $0.40/1K calls
    """
    return get("/seller", {"seller": seller_username})

profile = get_seller_profile("vintage_camera_shop")
print(
    profile["feedback_score"],
    profile["positive_feedback_rate"],
    profile["member_since"]
)

Operation 4 — Seller Inventory

GET /api/ebay/seller/items reads a seller's public listings, one page at a time.

def get_seller_inventory(seller_username, page=1):
    """
    Returns structured item cards from a seller's active listings.
    Paginate to collect the full inventory.

    For large inventories (100+ pages), use a background job
    when listed in the API catalog — only served pages are charged.
    Rate: $0.40/1K calls or served pages
    """
    return get("/seller/items", {
        "seller": seller_username,
        "page": page
    })

def collect_all_seller_items(seller_username, max_pages=10):
    """Collect a seller's full inventory page by page."""
    items = []
    for page in range(1, max_pages + 1):
        data = get_seller_inventory(seller_username, page)
        page_items = data.get("items", [])
        if not page_items:
            break
        items.extend(page_items)
        print(f"Page {page}: {len(page_items)} items")
    return items

Direct calls vs. background jobs: For a seller with 400 listings across 16 pages, a direct loop makes 16 synchronous calls. A background job submits once, handles retries internally, and charges only for pages that complete. If pages 15–16 don't complete, you're not charged for them. For large inventories, background jobs are both cheaper and more reliable.

Operation 5 — Product Reviews

GET /api/ebay/product/reviews returns buyer reviews for an eBay catalog product ID.

def get_product_reviews(product_id):
    """
    Returns: review text, star rating, author username, date.
    Note: requires an eBay catalog product_id (e-pid),
    not a listing item_id. These are different identifiers.

    Rate: $0.40/1K calls
    """
    return get("/product/reviews", {"product_id": product_id})

reviews = get_product_reviews("235190997")
for review in reviews.get("reviews", []):
    print(review["rating"], review["title"], review["date"])

The product_id vs item_id distinction: eBay has two identifier systems. An item_id identifies a specific listing from a specific seller. A catalog product ID (often called e-pid or epid) identifies a standardized product in eBay's catalog — the same physical product sold by many sellers. Reviews are attached to the catalog product, not to individual listings. If your workflow starts from search results, you'll need to extract the product ID from the item detail before calling reviews.

Operation 6 — Seller Feedback

GET /api/ebay/seller/feedback returns feedback entries left by buyers.

def get_seller_feedback(seller_username, page=1):
    """
    Returns: feedback entries with buyer username,
    positive/negative/neutral rating, comment text, date.

    Useful for: sentiment analysis, seller trust scoring,
    fraud signals, marketplace research.
    Rate: $0.40/1K calls
    """
    return get("/seller/feedback", {
        "seller": seller_username,
        "page": page
    })

feedback = get_seller_feedback("vintage_camera_shop")
for entry in feedback.get("feedback", []):
    print(entry["rating"], entry["comment"][:80])

A Complete Price Monitoring Pipeline

Here's how the operations compose into a real workflow:

import time
from datetime import datetime

def run_price_monitor(keywords, marketplaces, output_file="prices.jsonl"):
    """
    For each keyword × marketplace pair:
    1. Search listings (discovery)
    2. Get item detail for top N results (enrichment)
    3. Log price, condition, seller, timestamp

    Cost at Default tier ($0.40/1K):
    - 1 search call + N item calls per keyword/market pair
    - For 10 keywords × 3 markets × top-5 items:
      30 search calls + 150 item calls = 180 calls total
      180 / 1000 × $0.40 = $0.072 per run
    """
    import json

    results = []

    for keyword in keywords:
        for marketplace_id, locale in marketplaces:
            # Layer 1: Search
            search_data = search_listings(keyword, marketplace_id, locale)
            listings = search_data.get("listings", [])[:5]  # top 5 only

            for listing in listings:
                item_id = listing.get("item_id")
                if not item_id:
                    continue

                # Layer 2: Item detail (no description — not needed for price monitoring)
                try:
                    item = get_item(item_id)
                    record = {
                        "timestamp": datetime.utcnow().isoformat(),
                        "keyword": keyword,
                        "marketplace": marketplace_id,
                        "item_id": item_id,
                        "title": listing["title"],
                        "search_price": listing.get("price"),
                        "item_price": item.get("price"),
                        "currency": item.get("currency"),
                        "condition": item.get("condition"),
                        "seller": listing.get("seller"),
                        "availability": item.get("availability"),
                    }
                    results.append(record)

                    # Write incrementally so partial runs aren't lost
                    with open(output_file, "a") as f:
                        f.write(json.dumps(record) + "\n")

                except Exception as e:
                    print(f"Item {item_id} failed: {e}")

                time.sleep(0.1)  # gentle rate limiting

    return results

# Run it
KEYWORDS = ["vintage camera", "film camera", "polaroid camera"]
MARKETS = [
    ("EBAY_US", "en-US"),
    ("EBAY_GB", "en-GB"),
    ("EBAY_DE", "de-DE"),
]

data = run_price_monitor(KEYWORDS, MARKETS)
print(f"Collected {len(data)} price records")

Cost Reality Check

At the Default tier ($0.40/1K calls):

For price monitoring at meaningful scale — 100 keywords × 10 markets × 20 items daily — that's roughly 21,000 calls/day, $8.40/day at Default tier, $0.84/day at Scale tier ($0.03/1K after the $500 one-time deposit).

Start free: apiserpent.com/ebay-api — 10 calls, no card, covers the search + item workflow for initial testing.

Full endpoint reference: apiserpent.com/docs#ebay-api

eBay is a trademark of eBay Inc. Serpent API is not affiliated with or endorsed by eBay Inc.

7 SerpAPI Alternatives in 2026: Pricing, Scale, Free Tier & Comparison

API Serpent — Wed, 07 Oct 2026 06:31:23 +0000

If you're building an SEO tool, AI agent, search application, rank tracker, research product, or data pipeline, you eventually run into the same problem:

How do I get reliable search results without maintaining my own scraping infrastructure?

SerpAPI is one of the best-known solutions, but it isn't the only option.

There are now several APIs that approach search differently:

DataForSEO
Apify
Serper
Scrapingdog
Tavily
Serpent API
Exa

The important thing is that these aren't all solving exactly the same problem.

Some are traditional SERP APIs.

Some are scraping platforms.

Some are SEO data platforms.

And some are designed specifically for AI agents and semantic web search.

This guide compares them from a developer's perspective, including pricing, free usage, scaling, billing model, search-engine coverage, concurrency, SERP features, and the type of application each API is best suited for.

Pricing and feature information in this article was checked in October 2026. Provider pricing and limits can change, so verify the provider's pricing page before making a purchasing decision.

TL;DR

If you don't want to read the entire comparison:

Provider	Best for	Pricing approach	Free tier	Multi-engine
DataForSEO	Enterprise SEO/data pipelines	Pay-as-you-go	$1 credit + sandbox	Yes
Apify	Custom scraping & automation	Platform + usage	$5 usage	Actor-dependent
Serper	Simple Google Search API	Prepaid credits	2,500 queries	No
Scrapingdog	High-volume scraping/SERP	Monthly credits	200 credits	Multiple APIs
Tavily	AI agents & web research	Credit-based PAYGO	1,000 credits/month	Web search
Serpent API	Low-cost SERP + multi-engine search	Deposit/PAYGO	10 shared calls	5 engines
Exa	AI-native semantic search	PAYGO	$10/month + signup credits	Web index

For a traditional SERP application, I'd shortlist Serpent API, DataForSEO, Serper, and Scrapingdog.

For an AI agent or research product, I'd look first at Tavily and Exa.

For custom scraping infrastructure, Apify is in its own category.

1. What Makes a Good SERP API?

Before comparing prices, there are several things developers should look at.

The cheapest API isn't necessarily the cheapest API for your application.

I would evaluate at least these:

1. Price per request

How much does one successful search actually cost?

2. Billing model

Is it:

Monthly subscription?
Prepaid credits?
Pay-as-you-go?
Compute-based?
Credit-based?

3. Free tier

Can you prototype without entering a credit card?

4. Search-engine coverage

Does the API support:

Google
Bing
Yahoo
DuckDuckGo
Brave
Other engines?

5. SERP depth

Can you request 10, 50, or 100 results?

6. SERP features

Can you retrieve:

Organic results
Ads
People Also Ask
Featured snippets
AI Overviews
Local results
Images
Videos
Shopping

7. Geographic targeting

Can you request results for a specific country, language, or location?

8. Rate limits

How many requests can your application send per second?

9. Response consistency

Does the JSON structure stay predictable across engines and requests?

10. Latency

How quickly do you get the response?

These factors become much more important once your application moves beyond a prototype.

2. Quick Pricing Comparison

Here's the high-level pricing picture.

Provider	Entry pricing	Higher-volume pricing	Free usage	Billing
DataForSEO	$0.60 / 1K SERPs	$0.60 / 1K Standard	$1 credit	PAYGO
Apify	Free	$0.13/CU Business + Actor costs	$5 usage	Platform + usage
Serper	$1.00 / 1K	$0.30 / 1K	2,500 queries	Prepaid
Scrapingdog	$40 / 200K	~$0.067 / 1K at 3M	200 credits	Monthly
Tavily	$0.008 / credit	Custom plans	1,000 credits/month	PAYGO
Serpent API	$0.60 / 1K	$0.03 / 1K at Scale	10 shared calls	PAYGO
Exa	$7 / 1K Search	Custom Enterprise	$10/month + signup credits	PAYGO

One important warning:

These prices are not perfectly apples-to-apples.

DataForSEO bills based on SERP/result depth and method.

Apify combines Actor and compute costs.

Tavily uses API credits.

Exa charges according to its search/research products.

So don't simply sort this table by the lowest number.

3. DataForSEO

DataForSEO is much more than a simple Google search API.

It's an SEO data platform designed for applications that need large amounts of structured search and SEO data.

Its SERP API supports search engines including Google, Bing, Yahoo, Baidu, and Seznam, alongside other SEO-related APIs.

Pricing

DataForSEO currently publishes:

Standard: $0.0006 per SERP
Priority: $0.0012 per SERP
Live: $0.002 per SERP

That works out to:

$0.60 / 1K Standard SERPs
$1.20 / 1K Priority SERPs
$2.00 / 1K Live SERPs

The important detail is that a SERP represents a set of search results, and pricing can increase with depth and certain parameters.

Why developers choose DataForSEO

DataForSEO becomes interesting when you're building something like:

SEO platform
    ↓
Rank tracking
    ↓
Keyword database
    ↓
Backlinks
    ↓
SERP data
    ↓
Competitor analysis
    ↓
Technical SEO

Instead of stitching together several providers, you can build around a broader SEO data ecosystem.

Best for

Enterprise SEO products and large data pipelines.

Potential downside

If you only need:

GET keyword
→
return Google results

DataForSEO can be more infrastructure than you actually need.

4. Apify

Apify is fundamentally different from the other APIs on this list.

It's a scraping and automation platform.

Instead of buying one SERP endpoint, you can run different Actors that perform different tasks.

That means you can build workflows such as:

Search Google
    ↓
Extract results
    ↓
Visit websites
    ↓
Extract content
    ↓
Store dataset
    ↓
Run another Actor

This flexibility is extremely powerful.

Pricing

Apify has:

Free
Starter — $19/month
Scale — $199/month
Business — $999/month
Enterprise

Compute pricing decreases as you move up the plans.

Business currently lists $0.13 per compute unit.

The free plan includes $5 of usage.

Best feature

Flexibility.

You aren't limited to one API endpoint.

You can build or rent Actors for:

Google
Amazon
YouTube
social platforms
websites
data extraction
browser automation
custom scraping

Best for

Developers who need scraping infrastructure rather than simply a SERP API.

Potential downside

Your final cost can be more complicated because you may have:

Actor costs
compute
proxy usage
storage
data transfer

So comparing Apify's compute price directly against a SERP API's "per 1,000 searches" price isn't meaningful.

5. Serper

Serper takes the opposite approach.

It's extremely focused.

The core product is a Google Search API.

Its pitch is essentially:

Query
  ↓
Google
  ↓
Structured JSON

Current pricing

Serper currently offers:

Plan	Price	Credits	Effective price
Starter	$50	50K	$1.00 / 1K
Standard	$375	500K	$0.75 / 1K
Scale	$1,250	2.5M	$0.50 / 1K
Ultimate	$3,750	12.5M	$0.30 / 1K

There's also a free allowance of 2,500 queries.

The highest published tier supports up to 300 queries per second.

Serper says typical response times are around 1–2 seconds.

Why developers like it

The API is simple.

If your application only needs Google Search, you don't necessarily want a giant SEO platform.

You want:

{
  "search": "...",
  "results": [...]
}

Best for

Simple Google Search integrations.

Potential downside

If you need multiple search engines, Serper isn't as compelling as a multi-engine provider.

6. Scrapingdog

Scrapingdog focuses on scraping APIs and high-volume usage.

The pricing model is subscription-based, with increasingly large monthly credit allocations.

Current plans include:

Free — 200 credits
Lite — $40/month for 200K credits
Standard — $90/month for 1M credits
Pro — $200/month for 3M credits
Premium — $350/month for 6M credits
Business — $500/month for 9M credits

The platform continues into much larger enterprise tiers.

Interesting calculation

The Pro plan is:

$200 / 3,000,000 credits

≈ $0.067 per 1,000 credits

It also provides 100 concurrent requests at the Pro tier.

Higher plans continue increasing concurrency and monthly request volume.

Features

Scrapingdog provides APIs for areas including:

Search
Google SERP
Amazon
YouTube
News
Maps
social platforms
AI-related search features

It also provides geotargeting.

Best for

Developers who want a conventional scraping/SERP provider with large monthly quotas.

Potential downside

Unlike pure PAYGO providers, you are committing to a monthly credit plan.

If your traffic is unpredictable, that can matter.

7. Tavily

Tavily is where this comparison starts moving into a different category.

Tavily isn't primarily trying to reproduce a Google SERP.

It's designed for AI applications and agents.

A typical Tavily workflow looks like:

User question
      ↓
AI agent
      ↓
Tavily search
      ↓
Web sources
      ↓
Content extraction
      ↓
LLM
      ↓
Answer + citations

Pricing

Tavily currently offers:

Free — 1,000 API credits/month
PAYGO — $0.008/credit
Project plans
Enterprise

The free plan doesn't require a credit card.

Different API operations consume different amounts of credits.

Best for

AI agents
Research assistants
Chatbots
RAG
Web research
Citation-based answers

Not ideal for

Traditional rank tracking.

If you need:

keyword = "best football API"

position = 7

domain = example.com

a traditional SERP API is generally a better abstraction.

8. Serpent API

Serpent API takes a more traditional SERP approach while also supporting multiple search engines and AI-related search capabilities.

It supports:

Google
Bing
Yahoo
DuckDuckGo
Brave

The API provides a consistent JSON structure across the supported engines.

Pricing

The published SERP pricing is:

Tier	Price
Default	$0.60 / 1K
Growth	$0.06 / 1K
Scale	$0.03 / 1K

The Growth and Scale prices are unlocked through account balance/deposit tiers rather than a recurring monthly subscription.

That distinction is important.

You're not necessarily paying:

$500 every month

to get the Scale rate.

Instead, the balance determines the pricing tier.

Free tier

New accounts receive a shared lifetime pool of:

10 free calls

The pool can be used across the provider's supported APIs.

Search engines

Serpent supports:

Google
Bing
Yahoo
DuckDuckGo
Brave

SERP features

Depending on the endpoint, you can retrieve:

Organic results
Ads
People Also Ask
Featured snippets
AI Overviews
Knowledge panels
Local results
Videos
Shopping
Related searches

The Deep Search endpoint can request up to 100 results.

Interesting developer feature

Serpent also exposes pixel-position data for supported Deep Search requests.

That means a SERP result can contain information about where an element appears vertically on the rendered page.

That's useful for:

Above-the-fold analysis
SERP layout analysis
Share-of-voice calculations
SEO visibility analysis

Best for

Developers who want inexpensive traditional SERP infrastructure with multi-engine support.

9. Exa

Exa is another provider that shouldn't be treated as a simple SerpAPI clone.

It's designed around AI-native search.

The idea is closer to:

AI agent
   ↓
Search web
   ↓
Retrieve relevant sources
   ↓
Extract content
   ↓
Reason
   ↓
Produce answer

Pricing

Exa currently lists Search at:

$7 / 1K requests

Other products include:

Contents — $1 / 1K pages
Deep Search — $12 / 1K
Deep Reasoning Search — $15 / 1K
Answer — $5 / 1K
Monitors — $15 / 1K

Exa also has an Agent product with pricing based on compute and tool usage.

Free tier

The free tier includes:

$10 credits every month
$20 signup credits
10 Search QPS

No payment method is required for the free tier.

Best for

AI agents
Research systems
Semantic search
Company research
People search
Coding agents
Deep research

Potential downside

If you only need traditional Google ranking data, Exa is substantially more expensive than a dedicated SERP API.

10. Search Engine Comparison

Here's another way to look at the market.

Provider	Google	Bing	Yahoo	DuckDuckGo	Brave
DataForSEO	✓	✓	✓	—	—
Apify	Actor	Actor	Actor	Actor	Actor
Serper	✓	—	—	—	—
Scrapingdog	✓	✓	—	—	—
Tavily	Web index	Web index	Web index	Web index	Web index
Serpent API	✓	✓	✓	✓	✓
Exa	Web index	Web index	Web index	Web index	Web index

This is one of Serpent's strongest differentiators if your application needs to compare search engines.

11. SERP Feature Comparison

If you're building an SEO product, search-engine support isn't enough.

You also need the actual SERP features.

Feature	DataForSEO	Apify	Serper	Scrapingdog	Tavily	Serpent	Exa
Organic results	✓	✓	✓	✓	Web results	✓	Web results
Ads	✓	Actor	✓	✓	—	✓	—
PAA	✓	Actor	✓	✓	—	✓	—
Featured snippets	✓	Actor	✓	✓	—	✓	—
AI Overview	✓	Actor	✓	✓	—	✓	—
News	✓	Actor	✓	✓	✓	✓	✓
Images	✓	Actor	✓	✓	✓	✓	✓
Videos	✓	Actor	—	✓	✓	✓	✓
Maps	✓	Actor	—	✓	—	✓	—

The important distinction is that Tavily and Exa are web-search systems rather than traditional Google SERP reconstruction APIs.

That makes them excellent for AI applications but not necessarily the best choice for rank tracking.

12. What Does 1 Million Searches Cost?

This is one of the most useful ways to think about pricing.

Assuming the published entry/scale rates can be applied directly:

Provider	Approx. cost for 1M units
Serpent API — Scale	$30
Scrapingdog — Pro	~$67
Scrapingdog — Standard	$90
DataForSEO — Standard	~$600
Serper — Ultimate	~$300*
Tavily	Depends on credit consumption
Exa Search	~$7,000
Apify	Depends on Actor + compute

*Serper's $0.30/1K rate is attached to its 12.5M-credit Ultimate pack, so you aren't simply purchasing exactly 1M credits at that rate.

This is why advertised "per 1,000" prices need context.

The cheapest nominal unit price may require buying a much larger package.

13. Subscription vs PAYGO

This is another major difference.

Subscription-based

Scrapingdog is primarily monthly:

$40/month
$90/month
$200/month
...

This is predictable if your usage is stable.

But it can be inefficient if your usage changes significantly month to month.

Prepaid

Serper uses prepaid credits.

You purchase credits and consume them.

PAYGO

DataForSEO, Tavily, Exa and Serpent all provide usage-based models, although their units and pricing structures differ.

This can be attractive for:

startups
prototypes
variable traffic
serverless applications
applications with seasonal workloads

14. Which One Should You Choose?

There isn't one winner for every use case.

Choose DataForSEO if...

You are building a serious SEO platform.

You need:

rankings
keywords
backlinks
SERP data
technical SEO
advertising data
large-scale SEO datasets

DataForSEO is more of an SEO infrastructure platform than a simple search endpoint.

Choose Apify if...

Your problem is bigger than SERP.

For example:

Search Google
→ open 100 websites
→ scrape product information
→ extract prices
→ save dataset
→ run analysis

Apify's Actor ecosystem makes this type of workflow much easier.

Choose Serper if...

You just want Google Search.

It's hard to beat the simplicity:

query
→ Google
→ JSON

And the published pricing is straightforward.

Choose Scrapingdog if...

You want:

high monthly request volumes
scraping APIs
SERP APIs
geotargeting
increasing concurrency
predictable monthly billing

It's particularly interesting for production scraping applications.

Choose Tavily if...

You're building an AI agent.

For example:

User:
"Research the top competitors in this market."

AI Agent:
→ Tavily
→ Search
→ Extract
→ Reason
→ Cite sources

That's exactly the kind of workflow Tavily is designed around.

Choose Serpent API if...

You need traditional SERP data but want:

low cost
multiple search engines
simple JSON
usage-based pricing
SERP features
AI Overview data
high-volume search
no mandatory monthly subscription

The multi-engine support is especially useful if your application needs to compare Google, Bing, Yahoo, DuckDuckGo and Brave.

Choose Exa if...

You're building an AI-native search or research system.

Exa makes more sense for:

AI agent
→ semantic search
→ content retrieval
→ research
→ reasoning

rather than:

keyword
→ Google rank
→ position 13

15. The Real Takeaway

There isn't really one "best SerpAPI alternative."

There are different categories.

Traditional SERP

Serpent API
Serper
Scrapingdog

These are the closest choices when your application needs actual search-result data.

SEO infrastructure

DataForSEO

Better when search results are only one part of a much larger SEO application.

Scraping infrastructure

Apify

Better when you want to build custom scraping workflows.

AI web search

Tavily
Exa

Better when your application is an AI agent that needs web research and source retrieval.

Final Comparison

Provider	Best use case	Pricing style	Free tier	Scale	Multi-engine	AI-native
DataForSEO	SEO platforms	PAYGO	$1 credit	Excellent	Excellent	Medium
Apify	Scraping automation	Usage + platform	$5 usage	Excellent	Actor-dependent	Medium
Serper	Google Search	Prepaid	2,500	Excellent	No	Medium
Scrapingdog	High-volume scraping	Monthly	200	Excellent	Good	Medium
Tavily	AI agents	Credits	1K/month	Excellent	Web index	Excellent
Serpent API	SERP + multi-engine	PAYGO	10 calls	Excellent	5 engines	Strong
Exa	AI search/research	PAYGO	$10/month + signup credits	Excellent	Web index	Excellent

My shortlist

For a traditional SERP API:

Serpent API
DataForSEO
Serper
Scrapingdog

For AI search:

Exa
Tavily

For custom scraping:

Apify

The biggest mistake when comparing these APIs is looking only at the price per 1,000 requests.

For developers, the better question is:

What exactly does one request buy me, and how does the cost behave when my application reaches 100K, 1M, or 10M requests?

That's where the differences between these seven providers become much clearer.

Your SEO Tool Is Missing the Most Important Data in 2026

API Serpent — Mon, 05 Oct 2026 08:07:14 +0000

Let me save you six months.

If you're building an SEO tool right now and you only have SERP data, you have half an SEO tool. The half that was complete in 2023.

In 2026, there are five data layers a real SEO tool needs. Most tutorials cover two. Some cover three. Almost none cover the one that changed everything — Layer 4.

Layer 1 — Google Search Console Behavioral baseline. How does this domain actually perform in Google right now? Query impressions, CTR gaps, position trends. This is the only data source that comes from inside Google's own measurement. Everything else is inference. This is ground truth.

Layer 2 — Seed keywords + question queries Extract from GSC. Filter question-format queries with this regex:

^(who|what|when|where|why|how|which|can|does|do|is|are|should|will|could|would|did|was|were)\b

These are your AI search battleground keywords. Every question-format query is now being partially or fully answered by Gemini, ChatGPT, or Perplexity before the user ever clicks a result.

Layer 3 — SERP data Traditional search results for each seed keyword. Which pages rank? What's their content structure? This is your baseline competitor map.

Layer 4 — LLM citation data ← THE MISSING LAYER Same keywords. Same search intent. Different engine. Which domains does Gemini cite? Which does Perplexity recommend? Which does ChatGPT surface?

Here's what nobody's building for yet: find the pages that appear in both Layer 3 (traditional SERP) and Layer 4 (AI citations). Those pages have passed two completely different ranking algorithms. They are your highest-priority benchmark targets — the content that's winning both games simultaneously.

Copy their structure. Match their content depth. Then beat their backlink profile.

Layer 5 — Backlink profiles For each benchmark page, check where their backlinks come from. Not how many — where. A page with 200 relevant backlinks from your niche beats a page with 5,000 from content farms every time. Relevance is the metric. Find those niche sources. Build from the same places.

The data stack to build this:

GSC: Google Search Console API (free)
SERP + AI citations: Serpent API
Backlinks: DataForSEO

That's the whole architecture. The rest is UI.

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.