DEV Community: Elowen

What Data Should a SERP Result Actually Include?

Elowen — Wed, 10 Jun 2026 06:37:03 +0000

When developers work with search result data, it is tempting to think the only important field is ranking position.
In practice, a useful SERP record usually needs more context.
A basic organic result might include:

{
  "position": 1,
  "title": "Example result title",
  "url": "https://example.com",
  "domain": "example.com",
  "snippet": "Example search result snippet"
}

But for SEO workflows, that is often not enough.
Useful metadata can include:

keyword
location
language
device
timestamp
result type
visible position
organic position
ads presence
People Also Ask presence
related searches

The more context you store, the easier it becomes to understand why rankings changed and what the search result page actually looked like at that moment.

Best SERP APIs Compared: 1,009-Query Benchmark

Elowen — Wed, 03 Jun 2026 08:21:29 +0000

SERP APIs are often evaluated by price, latency, or the number of search engines they support. But for real production use, those are only part of the story.

If a SERP API returns fewer organic results, misses dates or snippets, fails to parse AI Overview, or produces unstable Top-1 rankings, the downstream impact can be significant. SEO rank tracking becomes noisy, AI/RAG systems lose useful context, and monitoring workflows may miss important pages.

That is why this benchmark looks beyond basic availability. Based on 1,009 identical-parameter queries, this article compares six SERP API providers across result completeness, URL consistency, field coverage, SERP feature parsing, and AI-oriented signals.

Data source: Talordata SERP 6-Platform Data Quality Comparison

Platforms compared: Talordata, Serpapi, Bright Data, Oxylabs, bd_fast, Serper.

1. Overall Ranking

Rank	Platform	Overall Score	Majority Alignment	SERP Feature Coverage	Positioning
1	Talordata	79.19	77.20%	36.20%	Balanced overall performance
2	Serpapi	78.06	75.01%	36.70%	Strong AI Overview and PAA coverage
3	Bright Data	77.80	78.43%	28.60%	Stable result quality and rich fields
4	Oxylabs	69.83	80.72%	5.40%	Strong precision / recall
5	bd_fast	61.85	77.88%	0%	Basic organic source
6	Serper	54.45	66.52%	2.40%	Lightweight fallback

The top three platforms are very close: Talordata scores 79.19, serpapi 78.06, and Bright Data 77.80, with only 1.39 points separating them.

serper returns an average of only 6.88 organic results per query, 22.3% fewer than Talordata. Its zero-result rate is 12.59%, which is 10.51 percentage points higher than Talordata.

2. Result Completeness

Platform	Rows	Avg Results / Query	Zero-Result Rate
Talordata	8,931	8.85	2.08%
Serpapi	8,908	8.83	2.28%
Bright Data	8,867	8.79	2.38%
Oxylabs	8,729	8.65	1.29%
bd_fast	8,761	8.68	9.51%
Serper	6,942	6.88	12.59%

Talordata returns the largest number of organic rows: 8,931. serper returns only 6,942, which is 1,989 fewer rows.

Oxylabs has the lowest zero-result rate at 1.29%. bd_fast has a decent average result count of 8.68, but its zero-result rate is 9.51%, suggesting that it fails outright on a noticeable portion of queries.

3. Core Field Completeness

The following field completeness metrics are calculated at the organic-row level.

Platform	title	link	snippet	position
Talordata	100%	100%	99.97%	100%
Serper	100%	100%	99.97%	100%
Serpapi	100%	100%	99.96%	100%
Bright Data	100%	100%	99.19%	100%
bd_fast	100%	100%	99.99%	100%
Oxylabs	100%	100%	100%	100%

All six platforms perform strongly on core organic fields. title, link, and position are essentially 100% complete, and snippet is above 99% for all platforms.

This means the core organic result payload is usable across all six providers. The bigger differences appear in enriched fields and SERP features.

4. Enriched Field Completeness

The following metrics are also calculated at the organic-row level.

Platform	source	display_link	date	favicon	snippet_highlighted	image	sitelinks	rating
Talordata	100%	100%	36.19%	92.16%	97.30%	12.12%	2.46%	0.83%
Serpapi	100%	100%	28.32%	92.30%	95.04%	0.21%	2.37%	0.94%
Bright Data	100%	100%	29.19%	92.11%	94.52%	13.94%	0.52%	1.26%
Serper	0%	0%	44.97%	0%	0%	0%	2.23%	0.69%
bd_fast	0%	0%	0%	0%	0%	0%	0%	0%
Oxylabs	0%	100%	0%	100%	0%	13.62%	0.49%	0.27%

Talordata, serpapi, and Bright Data have strong coverage for source, display_link, favicon, and snippet_highlighted.

For the date field, serper leads at 44.97%, followed by Talordata at 36.19%. Bright Data and serpapi are at 29.19% and 28.32%, respectively.

For image fields, Bright Data is at 13.94%, Oxylabs at 13.62%, and Talordata at 12.12%.

bd_fast has almost no enriched fields, making it better suited as a basic organic result source rather than a rich structured SERP source.

5. SERP Feature Coverage

The following query-level metrics show the percentage of the 1,009 queries where each platform parsed a given SERP feature.

Platform	AI Overview	PAA	Related	Images	Videos	Knowledge Graph	Answer Box	Pagination
Serpapi	69.4%	64.0%	43.0%	17.9%	8.5%	2.3%	1.0%	87.3%
Talordata	64.5%	62.9%	42.1%	22.3%	8.1%	1.8%	0.3%	87.1%
Bright Data	3.2%	62.1%	44.1%	22.0%	8.1%	2.2%	0.5%	86.2%
Oxylabs	0%	0%	43.1%	0%	0%	0%	0%	0%
Serper	0%	10.0%	7.5%	0%	0%	0%	2.0%	0%
bd_fast	0%	0%	0%	0%	0%	0%	0%	0%

serpapi has the highest AI Overview coverage at 69.4%, followed by Talordata at 64.5%. The two are very close on PAA, Related, and Pagination.

Talordata has stronger Images coverage than serpapi: 22.3% vs 17.9%, and is close to Bright Data’s 22.0%.

Bright Data has low AI Overview coverage at 3.2%, but strong coverage on PAA, Related, Images, Videos, and Pagination.

6. AI Use-Case Performance

AI Score is the AI-use-case composite score provided by the benchmark page.

Platform	AI Score	AI Overview	PAA	Related	date	Precision	Recall	Zero-Result Rate
Serpapi	60.66	69.38%	64.02%	43.01%	28.32%	75.01%	89.32%	2.28%
Talordata	60.50	64.52%	62.93%	42.12%	36.19%	77.20%	92.11%	2.08%
Bright Data	41.83	3.17%	62.14%	44.10%	29.19%	78.43%	92.90%	2.38%
Oxylabs	33.74	0%	0%	43.11%	0%	80.72%	94.32%	1.29%
Serper	29.72	0%	10.01%	7.53%	44.97%	66.52%	61.37%	12.59%
bd_fast	29.19	0%	0%	0%	0%	77.88%	90.89%	9.51%

The top two AI Scores are almost tied: serpapi at 60.66 and Talordata at 60.50, a difference of only 0.16.

Serpapi’s main advantage is AI Overview coverage, where it leads Talordata by 4.86 percentage points. Talordata leads on date, Precision, and Recall: date by 7.87 points, Precision by 2.19 points, and Recall by 2.79 points.

7. Precision / Recall / F1

Platform	Precision	Recall	F1
Oxylabs	80.72%	94.32%	86.99
Bright Data	78.43%	92.90%	85.05
Talordata	77.20%	92.11%	84.00
bd_fast	77.88%	90.89%	83.88
Serpapi	75.01%	89.32%	81.54
Serper	66.52%	61.37%	63.84

Oxylabs ranks first across Precision, Recall, and F1, with an F1 score of 86.99.

Bright Data, Talordata, and bd_fast are close, with F1 scores of 85.05, 84.00, and 83.88.

serper is significantly lower, with an F1 score of 63.84.

8. Cross-Platform Consistency

The table below shows each platform’s average consistency against the other five providers.

Platform	Avg Top-1 vs Others	Avg URL Jaccard vs Others
Oxylabs	74.02%	64.22%
Bright Data	72.06%	62.90%
Talordata	71.94%	62.10%
bd_fast	73.26%	59.56%
Serpapi	69.38%	60.80%
Serper	54.66%	43.82%

Oxylabs has the highest average Top-1 consistency and URL Jaccard. Serper is clearly lower on both metrics, indicating that its returned results diverge more from the rest of the group.

9. Query Type Impact on Consistency

Query Type	N	Avg URL Jaccard	Avg Top-1
Chinese plain queries	113	54.77%	62.98%
English + quotes	620	56.60%	70.21%
English plain queries	60	59.06%	67.13%
Chinese + quotes	177	66.99%	70.21%
site: operator	39	70.28%	87.50%

site: operator queries have the highest consistency, with an average Top-1 hit rate of 87.50% and URL Jaccard of 70.28%.

Chinese plain queries have the lowest consistency, with URL Jaccard at 54.77% and Top-1 at 62.98%.

This indicates that query type has a clear impact on SERP API comparison results. More specific queries with smaller candidate sets tend to produce higher agreement, while broad plain queries are more volatile.

10. Use-Case Selection Guide

Use Case	Priority Metrics	Platforms to Prioritize
SEO rank tracking	Top-1, Top-10, position, zero-result rate	Talordata, Bright Data, Oxylabs
AI / RAG	AI Overview, PAA, Related, snippet, date, Recall	serpapi, Talordata
Brand / media monitoring	date, Recall, zero-result rate, result completeness	Talordata, Bright Data, serper
Data engineering ingestion	Field completeness, schema richness, rows	Talordata, serpapi, Bright Data
Basic organic scraping	Avg results/query, zero-result rate, core field completeness	Talordata, serpapi, Oxylabs, bd_fast
High-quality result validation	Precision, Recall, F1	Oxylabs, Bright Data, Talordata

11. Conclusion

Across 1,009 queries, Talordata, serpapi, and Bright Data are the closest in overall performance, with scores of 79.19, 78.06, and 77.80. The gap between first and third place is only 1.39 points.

For AI use cases, serpapi and Talordata are nearly tied: 60.66 vs 60.50. serpapi leads in AI Overview coverage, while Talordata leads in date coverage, Precision, and Recall.

For result quality, Oxylabs has the highest F1 score at 86.99; Bright Data, Talordata, and bd_fast follow at 85.05, 84.00, and 83.88.

For field richness, Talordata, serpapi, and Bright Data clearly outperform bd_fast and serper. bd_fast can serve as a basic organic source, but it has almost no enriched fields or SERP feature coverage.

For consistency, Bright Data, Oxylabs, and Talordata show stronger URL Jaccard and Top-1 alignment, while serper has noticeably lower overlap with other platforms.

SERP API selection should not rely on average result count alone. SEO use cases should prioritize Top-1 consistency and position data; AI/RAG use cases should prioritize AI Overview, PAA, Related, and snippet quality; data engineering workflows should prioritize field completeness and schema stability.

How to build a Google rank tracker with TalorData (Python)

Elowen — Thu, 28 May 2026 12:56:20 +0000

Tracking where a domain ranks for a list of keywords on Google sounds like a one-afternoon project. It is — until you try to scrape google.com yourself. After a few hundred requests from the same IP you start getting the consent page, then a captcha, then nothing at all. Rotating proxies and headless browsers works for a while, but you end up spending more time keeping the scraper alive than using its data.

Easier path: hand that problem to a SERP API and keep your code focused on the rank itself.

This walks through a small rank tracker in Python using TalorData's SERP API. Single request first, parse the response, look up a target domain's position in the organic results, then loop over a keyword list and persist the history to SQLite so it can be charted.

Get a token

TalorData returns Google (and Bing/Yandex/etc.) results as structured JSON. Sign up at talordata.com, grab the bearer token from the dashboard, export it:

First request

The endpoint takes form-encoded POST. Smallest useful call — Google search for serp api, US desktop, top 10:

curl -X POST 'https://serpapi.talordata.net/serp/v1/request' \
  -H "Authorization: Bearer $TALORDATA_TOKEN" \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'engine=google' \
  -d 'q=serp api' \
  -d 'device=desktop' \
  -d 'location=United States' \
  -d 'num=10' \
  -d 'json=1'

Top-level keys in the response:

organic
sponsored_results
pagination
people_also_ask
people_are_saying
related
request_params
search_information
search_metadata

For ranking the only one that matters is organic. The rest are useful for other things — people_also_ask for content ideas, sponsored_results to see who's bidding on the term, pagination to go past page one — but the rank lives in organic.

Parse it in Python

import os
import requests

ENDPOINT = "https://serpapi.talordata.net/serp/v1/request"
TOKEN = os.environ["TALORDATA_TOKEN"]


def search(query: str, location: str = "United States", num: int = 10) -> dict:
    resp = requests.post(
        ENDPOINT,
        headers={
            "Authorization": f"Bearer {TOKEN}",
            "Content-Type": "application/x-www-form-urlencoded",
        },
        data={
            "engine": "google",
            "q": query,
            "device": "desktop",
            "location": location,
            "num": num,
            "json": 1,
        },
        timeout=60,
    )
    resp.raise_for_status()
    return resp.json()


data = search("serp api")
for r in data["organic"][:5]:
    print(f'{r["position"]:>2}  {r["display_link"]}')
    print(f'    {r["title"]}')

Output:

 1  https://serpapi.com
    SerpApi: Google Search API
 2  https://brightdata.com› products › serp-api
    SERP API - SERP Scraper API - Free Trial
 3  https://dataforseo.com› APIs
    SERP API You Can Trust
 4  https://serper.dev
    Serper - The World's Fastest and Cheapest Google Search API
 5  https://github.com› serpapi › google-search-results-python
    serpapi/google-search-results-python

Each entry in organic has position, title, link, display_link, description, source, plus sometimes snippet_highlighted_words and redirect_link. display_link is the breadcrumb URL Google renders under the title — close to but not the same as link. For domain matching use the host of link.

Find a target domain's rank

from urllib.parse import urlparse


def find_rank(target_domain: str, organic: list) -> int | None:
    target = target_domain.lower().removeprefix("www.")
    for r in organic:
        host = (urlparse(r["link"]).hostname or "").removeprefix("www.")
        if host == target or host.endswith("." + target):
            return r["position"]
    return None


TARGET_DOMAIN = "github.com"  # change this to the domain you want to track
print(find_rank(TARGET_DOMAIN, data["organic"]))
# 5

Two things worth knowing. The endswith branch handles subdomains, so docs.github.com still counts as a github.com hit — change that behavior if you want exact-host matching. And if the domain isn't in the slice you requested, you get None, not an exception. None means "not in top N", not "doesn't rank" — bump num to 100 if you want to know whether it's anywhere on the first ten pages.

Track a list of keywords over time

One ranking is a data point. A tracker is a series. SQLite is enough for this — single file, ships with Python, no server.

import sqlite3
from datetime import date

KEYWORDS = [
    "serp api",
    "google search api",
    "scrape google results",
    "rank tracker python",
    "google serp scraper",
    "google search json api",
]

DB = sqlite3.connect("rankings.db")
DB.executescript("""
CREATE TABLE IF NOT EXISTS rankings (
    day      TEXT NOT NULL,
    keyword  TEXT NOT NULL,
    domain   TEXT NOT NULL,
    rank     INTEGER,
    PRIMARY KEY (day, keyword, domain)
);
""")


def track(domain: str, keywords: list[str]) -> None:
    today = date.today().isoformat()
    for kw in keywords:
        data = search(kw, num=100)
        rank = find_rank(domain, data["organic"])
        DB.execute(
            "INSERT OR REPLACE INTO rankings VALUES (?, ?, ?, ?)",
            (today, kw, domain, rank),
        )
        print(f"{kw:<28} -> {rank}")
    DB.commit()


track(TARGET_DOMAIN, KEYWORDS)

INSERT OR REPLACE means you can re-run on the same day without primary-key errors — useful if the run dies halfway through. num=100 is deliberate: most of these keywords won't put the target on page one, and a wall of Nones isn't useful data. One request returns up to a hundred results for the same cost as ten.

Sample run:

serp api                     -> 5
google search api            -> 12
scrape google results        -> 8
rank tracker python          -> None
google serp scraper          -> 23
google search json api       -> 7

Chart

Once a few days are in the table, the plot is small:

import matplotlib.pyplot as plt

OFF_RADAR = 101  # plot NULL ranks just below the visible range


def plot(keyword: str, domain: str) -> None:
    cur = DB.execute(
        "SELECT day, rank FROM rankings "
        "WHERE keyword = ? AND domain = ? ORDER BY day",
        (keyword, domain),
    )
    rows = cur.fetchall()
    days = [r[0] for r in rows]
    ranks = [r[1] if r[1] is not None else OFF_RADAR for r in rows]

    fig, ax = plt.subplots(figsize=(8, 4))
    ax.plot(days, ranks, marker="o")
    ax.invert_yaxis()
    ax.set_ylim(OFF_RADAR + 5, 0)
    ax.set_title(f'{domain} — "{keyword}"')
    ax.set_ylabel("Google rank (1 = top)")
    fig.autofmt_xdate()
    fig.tight_layout()
    fig.savefig(f"{keyword.replace(' ', '_')}.png", dpi=120)


plot("serp api", TARGET_DOMAIN)

invert_yaxis is the bit that makes the chart read correctly — rank 1 at the top, a drop in position is a line going down. Mapping None to 101 keeps dropouts visible instead of leaving holes in the series; pick a different cutoff if you only care about the top ten.

Wrapping up

The whole thing is about 80 lines of Python. One endpoint, one parser, a SQLite table, a matplotlib chart.

Two obvious extensions: add a second domain so you can plot two lines on the same axes, and split desktop and mobile into their own runs since they don't always agree.

Talordata: A Multi-Engine SERP API for Google, Bing, Yandex

Elowen — Thu, 28 May 2026 12:46:02 +0000

What is Talordata

Talordata is a SERP API that returns structured JSON from Google, Bing, Yandex, and Baidu through a single endpoint — so you can skip building scrapers, rotating proxies, and writing HTML parsers.

Positioning: a multi-engine, 1:1 billed, transparently priced SERP data source for global traffic.

Core Features

Four engines, one API — Google / Bing / Yandex / Baidu under the same call. Built for teams that need multi-language or multi-region coverage (Russian, Chinese, Southeast Asian markets).
1:1 billing — one request, one credit. No 5x / 25x multipliers.
Structured JSON output — ready to use, no parser maintenance.
Geo & language targeting — country-level location with country-set support, plus a language parameter for cross-border, multi-language search.
AI Overview support — parse Google's AI Overview blocks directly, matching what 2026 SEO tools and RAG apps actually need.

Pricing

Plan	Quota	Unit Price	Total	Period
Free Trial	1,000 responses	$0	$0	7 days
Starter	30,000 responses	$0.90 / 1K	$27	30 days
Growth	100,000 responses	$0.70 / 1K	$70	30 days
Scale	500,000 responses	$0.60 / 1K	$300	30 days
Pro	3,000,000 responses	$0.45 / 1K	$1,350	30 days
Best Price	10,000,000 responses	$0.25 / 1K	$2,500	30 days

How it compares: SerpAPI's entry tier sits around $10 / 1K. Talordata's entry tier is $0.90 / 1K — an order of magnitude cheaper. At the high end, $0.25 / 1K matches Serper.dev, but you get three additional engines for the same price.

Credit expiration: if your credits expire, buying any new plan automatically restores the expired credits — so prior spend isn't wasted.

Overage: requests beyond your quota are rejected rather than billed. No surprise charges; spend stays predictable.

Quick Start

One curl call to get going:

curl -X POST 'https://serpapi.talordata.net/serp/v1/request' \
  -H 'Authorization: Bearer Talordata_token' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'engine=google' \
  -d 'q=serp api' \
  -d 'device=desktop' \
  -d 'location=United States' \
  -d 'num=10' \
  -d 'ai_overview=true' \
  -d 'uule=w+CAIQICIVW5pdGVkIFN0YXRlcw==' \
  -d 'json=2'

Parameters:

engine — search engine: google / bing / yandex / baidu
q — search query
device — desktop or mobile
location — country-level geo target
num — number of results
ai_overview — parse AI Overview block
uule — Google's encoded location parameter
json — response format version

Why Talordata

Multi-engine is a real differentiator. One interface, three engines.
Transparent 1:1 pricing across tiers. $0.25 / 1K.
Native AI Overview + credit-rollback policy. You stay aligned with the 2026 AI search shift, and credits never go to waste — large buyers don't have to worry about losing budget on rollover.

How to Get Google Search Results as JSON

Elowen — Tue, 26 May 2026 11:56:34 +0000

Google search results are useful for many products and workflows: SEO tools, keyword research, content monitoring, market research, AI agents, and ranking trackers.

But Google search result pages are not easy to use directly in software. The HTML changes often, results differ by country and language, and manually parsing search pages can become fragile very quickly.

A SERP API solves this problem by returning Google search results in a structured JSON format.

In this article, we will walk through how to get Google search results as JSON using TalorData SERP API.

What We Are Building

We will send a Google search query to a SERP API and receive a JSON response that contains structured search result data.

For example, instead of manually opening Google and searching:

best ai resume builder

We can send the keyword to an API and get results like:

{
  "organic_results": [
    {
      "title": "Best AI Resume Builder",
      "link": "https://example.com",
      "snippet": "Create a professional resume with AI..."
    }
  ]
}

This makes the data easier to store, analyze, compare, or use inside an application.

Use Cases

Getting Google search results as JSON is useful when you need to:

Track keyword rankings
Monitor competitors in search results
Analyze SEO opportunities
Collect People Also Ask questions
Check whether ads appear for a keyword
Build AI or RAG workflows with live search context
Compare search results across different countries or languages

API Request Example

TalorData SERP API supports Google search requests and can return structured JSON data.

Here is a basic curl example:

curl -X POST "https://serpapi.talordata.net/serp/v1/request" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "engine=google" \
  -d "q=best ai resume builder" \
  -d "json=2"

Replace YOUR_API_KEY with your own TalorData API key.

You can register a TalorData account and get an API key from the official website:

https://www.talordata.com/

Request Parameters

The basic request contains three important fields:

Parameter	Meaning
`engine`	The search engine to use. In this example, `google`.
`q`	The keyword or search query.
`json`	The response format option. `json=2` returns structured JSON.

For a simple Google search JSON request, this is enough to start.

Python Example

Here is a simple Python script that sends a Google search query and prints the JSON response.

import requests
import json

API_KEY = "YOUR_API_KEY"

url = "https://serpapi.talordata.net/serp/v1/request"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/x-www-form-urlencoded",
}

data = {
    "engine": "google",
    "q": "best ai resume builder",
    "json": "2",
}

response = requests.post(url, headers=headers, data=data, timeout=30)
response.raise_for_status()

result = response.json()

print(json.dumps(result, indent=2, ensure_ascii=False))

Run the script:

python get_google_results.py

If the request succeeds, you will receive Google search results in JSON format.

Extract Organic Results

Most applications do not need the entire JSON response. Usually, you only need specific fields, such as organic results.

Here is an example:

organic_results = result.get("organic_results", [])

for index, item in enumerate(organic_results, start=1):
    title = item.get("title")
    link = item.get("link")
    snippet = item.get("snippet")

    print(index, title)
    print(link)
    print(snippet)
    print()

Example output:

1 Best AI Resume Builder
https://example.com
Create a professional resume with AI...

2 Free Resume Builder Online
https://example.org
Build a resume online for free...

Now the search results are no longer just a web page. They are structured data that your program can process.

Save Results to a CSV File

If you want to analyze search results in Excel, Google Sheets, or a database, you can export the data to CSV.

import csv

organic_results = result.get("organic_results", [])

with open("google_results.csv", "w", newline="", encoding="utf-8-sig") as f:
    writer = csv.writer(f)
    writer.writerow(["position", "title", "link", "snippet"])

    for index, item in enumerate(organic_results, start=1):
        writer.writerow([
            index,
            item.get("title", ""),
            item.get("link", ""),
            item.get("snippet", ""),
        ])

After running the script, you will get a file:

google_results.csv

The CSV may look like this:

position	title	link	snippet
1	Best AI Resume Builder	https://example.com	Create a professional resume with AI...
2	Free Resume Builder Online	https://example.org	Build a resume online for free...

Full Python Script

Here is the complete example:

import requests
import json
import csv

API_KEY = "YOUR_API_KEY"

url = "https://serpapi.talordata.net/serp/v1/request"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/x-www-form-urlencoded",
}

data = {
    "engine": "google",
    "q": "best ai resume builder",
    "json": "2",
}

response = requests.post(url, headers=headers, data=data, timeout=30)
response.raise_for_status()

result = response.json()

print(json.dumps(result, indent=2, ensure_ascii=False))

organic_results = result.get("organic_results", [])

with open("google_results.csv", "w", newline="", encoding="utf-8-sig") as f:
    writer = csv.writer(f)
    writer.writerow(["position", "title", "link", "snippet"])

    for index, item in enumerate(organic_results, start=1):
        writer.writerow([
            index,
            item.get("title", ""),
            item.get("link", ""),
            item.get("snippet", ""),
        ])

print("Saved results to google_results.csv")

What You Can Do Next

Once you can get Google search results as JSON, you can build more useful workflows on top of it.

For example:

Run the same keyword every day and track ranking changes
Compare search results across multiple countries
Collect the top ranking domains for a keyword group
Detect whether ads appear for commercial keywords
Extract People Also Ask questions for content ideas
Export search results into a dashboard or database

Common Issues

1. Invalid API Key

If the API key is wrong or missing, the request may fail with an authentication error.

Check this line:

API_KEY = "YOUR_API_KEY"

Make sure it contains your real API key.

2. Empty Results

If the response does not contain organic results, check:

Whether the keyword is valid
Whether the request succeeded
Whether the response field name matches your parsing logic
Whether the selected search engine supports the requested query

3. Timeout

If the request times out, increase the timeout value:

response = requests.post(url, headers=headers, data=data, timeout=60)

Conclusion

Using a SERP API is one of the simplest ways to get Google search results as JSON.

Instead of scraping and parsing Google result pages manually, you can send a search query to an API and receive structured data that is easier to use in software.

With this basic workflow, you can build ranking trackers, SEO research tools, competitor monitoring systems, content research workflows, and search-based AI applications.

I Used a SERP API to Validate an AI Resume Builder Idea

Elowen — Sat, 23 May 2026 09:59:52 +0000

You may have an idea: building an AI resume builder, a PDF tool site, a small SaaS product, a content site, an affiliate site, a niche directory, or even a local service website. The first question is simple: is this direction actually worth building?

Many people judge by instinct: this niche seems popular, there seem to be many existing sites, and users probably need it. But before you start building, a more reliable approach is to look at search results. Search results already contain user demand, page types, content formats, and commercial signals.

This article walks through a complete workflow: starting from a project idea, using the TalorData SERP API to collect real search results, turning those results into tables, and then deciding whether the direction has an opportunity.

We will use AI Resume Builder as the example. The same method can also be applied to tool sites, SaaS products, content sites, affiliate sites, directories, and local service websites.

What You Will Get at the End

By following this article, you will produce three tables:

Keyword candidate table: turn a project idea into a set of searchable keywords.
SERP result table: use the SERP API to check each keyword and collect ranking pages, PAA, ads, domains, and other useful signals.
Opportunity decision table: use simple rules to decide which keywords are worth targeting and which ones should be postponed or avoided.

At the end, you should be able to answer three questions:

Is there real search demand for this direction?
Which sites are already ranking in search results?
If I build this now, which keyword or feature should I start with?

Step 1: Turn the Idea into Searchable Keywords

Let's start with a concrete idea: I want to build an AI Resume Builder.

This idea is still too broad. You cannot judge the whole project with only one phrase, because a project usually contains many different user needs. Some users want a free tool. Some want an online resume builder. Some want a cover letter generator. Some only need a resume summary generator.

So the first step is not writing code or calling an API. The first step is turning the idea into search queries that real users might type into Google.

Step 2: Where the Keywords Come From

Keywords should not be guessed randomly. You can get the first batch from several sources.

1. Break Down the Core Features

For an AI Resume Builder, you can start with the core features:

Resume generation: ai resume builder
Online resume tool: resume builder online
Free resume tool: free resume builder
Resume summary generation: resume summary generator
Cover letter generation: cover letter generator
Resume bullet point generation: resume bullet point generator

2. Expand with User Modifiers

When users search for tools, they often add modifiers such as:

best, for example best resume builder
free, for example free resume builder
online, for example resume builder online
generator, for example resume summary generator
template, for example resume template
alternative, for example zety alternative

3. Add Keywords from Search Suggestions and Existing Pages

You can also expand keywords from Google autocomplete, People Also Ask, existing page titles, and discussions on Reddit or Quora.

If you do not know where to start, you can use ChatGPT to generate an initial keyword list, then use a SERP API to verify whether those keywords actually have search results and ranking pages.

Step 3: Create `keywords.csv`

Put the keywords into a CSV file. Keep the first version simple, with only one column: keyword.

keyword
ai resume builder
resume builder online
free resume builder
resume summary generator
cover letter generator
resume bullet point generator
ai cover letter generator
best resume builder

If you are testing a different project, just replace this column. For example:

PDF tool site: pdf compressor online, merge pdf online, pdf to word converter
SaaS: email verification API, invoice software, booking software
Content site: best dog food for puppies, how to train a puppy
Local service site: plumber near me, emergency dentist near me

Step 4: Query Keywords with the TalorData SERP API

Next, send one SERP API request for each keyword. You can register a TalorData account and get an API key with free credits from the official website.

Keep in mind that API requests consume quota. In general, one keyword means at least one request. If you prepare 20 keywords, the test will use around 20 requests. Before expanding the test, start with 5-10 keywords to make sure the workflow works.

The basic TalorData request format looks like this:

curl -X POST 'https://serpapi.talordata.net/serp/v1/request' \
  -H 'Authorization: Bearer YOUR_TALORDATA_API_KEY' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'engine=google' \
  -d 'q=ai resume builder' \
  -d 'json=2'

This request returns Google SERP data for the keyword. For decision-making, we mainly care about these fields:

organic results: natural search results, used to see who ranks at the top.
People Also Ask: user questions, used to identify content opportunities.
ads: advertising results, if available, used to estimate commercial value.
titles and URLs: used to understand page types.
domains: used to identify and count the sites that appear in search results.

Step 5: Run the Script and Generate the Result Table

The script reads keywords.csv, queries the TalorData SERP API, and outputs two files:

serp_opportunities.csv: the analysis table used for judging opportunities.
serp_raw_records.jsonl: the raw crawl records, useful for checking how each conclusion was produced.

In the main article, we only show the key part of the code:

TALORDATA_API_KEY = "YOUR_TALORDATA_API_KEY_HERE"
ENDPOINT = "https://serpapi.talordata.net/serp/v1/request"

headers = {
    "Authorization": f"Bearer {TALORDATA_API_KEY}",
    "Content-Type": "application/x-www-form-urlencoded",
    "User-Agent": "curl/8.0.0",
}

data = {
    "engine": "google",
    "q": keyword,
    "json": "2",
}

response = requests.post(ENDPOINT, headers=headers, data=data, timeout=60)
response.raise_for_status()
result = response.json()

This is the part that sends a keyword to TalorData and receives the SERP response. The full script is included at the end of the article.

Step 6: Look at the Result Table Before Judging the Opportunity

The script will produce a table similar to this:

keyword	organic_count	paa_count	ads_present	top_domains	Initial read
ai resume builder	10	4	true	resume.io, resumegenius.com, enhancv.com	Demand is clear, but competition is strong
free resume builder	10	5	true	canva.com, zety.com, resume.com	Strong free-tool demand and obvious commercial competition
resume summary generator	9	6	false	tealhq.com, resumeworded.com, kickresume.com	Better long-tail opportunity
cover letter generator	10	4	true	grammarly.com, resumegenius.com, zety.com	Suitable as a feature page entry point

This table is your first project opportunity map. It shows demand strength, ranking-site patterns, and commercial signals behind each keyword.

Step 7: How to Decide Whether a Signal Is Strong or Weak

When judging opportunities, avoid vague words like "many", "few", "strong", or "weak". Use simple rules instead.

Signal	How to Judge	What It Means
PAA >= 4	Many questions	Rich user needs; suitable for content pages or FAQ
PAA 1-3	Some questions	Some content opportunity
PAA = 0	Few questions	Limited room for content expansion
ads_present = true	Ads exist	The keyword may have commercial value
Top 10 has 2+ small sites	Better new-site opportunity	The SERP is not fully dominated by major brands
Top 10 is almost all major sites	Strong competition	New sites should avoid attacking the core keyword directly

Here, major sites mean strong brands, platforms, or high-authority websites, such as Canva, LinkedIn, Indeed, HubSpot, Forbes, and Wikipedia.

Small sites usually mean niche tool sites, small SaaS products, personal blogs, niche content sites, or emerging product sites.

You should also keep clear "give up" signals. If almost every keyword has a Top 10 dominated by major sites, very few PAA questions, no ads, and no small sites ranking, the direction may have weak demand or may already be heavily monopolized. In that case, do not force the conclusion that it is still worth doing. A better move is to switch to a more specific keyword or choose another direction.

Step 8: Turn the Result into a Conclusion

Now let's go back to the AI Resume Builder example. Based on the sample results, we can make these judgments:

ai resume builder: strong demand, but also strong competition. It is not a good first breakthrough keyword.
free resume builder: high traffic and commercial value, but many major brands compete for it.
resume summary generator: more specific, with many PAA questions, suitable as an early entry point.
cover letter generator: clear demand, suitable as a second feature page.

So the direction is not "not worth doing". The real conclusion is: do not start by attacking the hardest core keyword. A more practical starting point is to build specific feature pages first, then expand toward the main tool page.

Step 9: Create Your Opportunity Decision Table

Finally, convert each keyword into a clear decision.

keyword	Opportunity Level	Suggested Action
ai resume builder	Medium	Treat it as a long-term target, not the first keyword to attack
free resume builder	Medium	Has traffic and commercial value, but needs differentiation
resume summary generator	High	Suitable as one of the first feature pages
cover letter generator	High	Suitable as a feature expansion page
best resume builder	Medium-low	Better for later comparison content

The goal is not to produce an absolutely correct answer. The goal is to decide where to put resources first: which pages to build now, which keywords to postpone, and which directions are not worth continuing.

Optional: Turn the Rules into a Simple Score

If you want more automation, you can turn the rules from Step 7 into a simple scoring function. This lets the script output an initial score for each keyword.

def score_keyword(paa_count, ads_present, big_site_count, small_site_count):
    score = 0

    if paa_count >= 4:
        score += 2
    elif paa_count >= 1:
        score += 1

    if ads_present:
        score += 2

    if small_site_count >= 2:
        score += 2

    if big_site_count >= 4:
        score -= 2

    if score >= 4:
        return "High"
    if score >= 2:
        return "Medium"
    return "Low"

This score should not replace human judgment, but it can help you quickly identify which keywords deserve attention first.

Step 10: Apply the Method to Your Own Project

This method can be reused across many project types. You only need to replace the keywords.

Project Type	Example Keyword	What You Can Validate
Tool site	pdf compressor online	Tool demand, existing tools, free/paid opportunity
SaaS	email verification API	Commercial intent, SaaS sites, pricing-page competition
Content site	best dog food for puppies	Content opportunity, PAA questions, affiliate opportunity
Directory site	best AI tools for students	Listicle opportunity and existing directory sites
Local service site	plumber near me	Local competition, local pack, service provider rankings

The general workflow is:

Project idea -> Find keywords -> Query with TalorData SERP API -> Get result table -> Judge opportunity by rules -> Decide whether to build and where to start

Conclusion

A project direction should not be judged only by instinct. You need to look at real search results to understand demand, commercial value, existing ranking sites, and possible entry points.

The value of a SERP API is that it turns Google search results into data you can analyze in batches.

For a new project, the best direction is not always the most popular one. A better direction is one with search demand, commercial value, room for content or feature expansion, and a realistic entry point for a new site.

If you already have an idea, start with 5-10 keywords and run this workflow once. You will have a much clearer view of whether the direction is worth building and where your first step should be.

Full Python script

# -*- coding: utf-8 -*-
import csv
import json
from datetime import datetime
from pathlib import Path
from urllib.parse import urlparse

import requests


ROOT = Path(__file__).resolve().parent
ENDPOINT = "https://serpapi.talordata.net/serp/v1/request"
TALORDATA_API_KEY = "YOUR_TALORDATA_API_KEY_HERE"
SERP_PAGE = ""
SERP_NUM = ""


def get_domain(url):
    try:
        return urlparse(url).netloc.replace("www.", "")
    except Exception:
        return ""


def normalize_serp_response(result):
    serp_json = result.get("data", {}).get("json", result)
    if isinstance(serp_json, str):
        return json.loads(serp_json)
    return serp_json


def find_first(data, keys):
    if isinstance(data, dict):
        for key in keys:
            if key in data:
                return data[key]
        for value in data.values():
            found = find_first(value, keys)
            if found is not None:
                return found
    elif isinstance(data, list):
        for item in data:
            found = find_first(item, keys)
            if found is not None:
                return found
    return None


def as_list(value):
    if isinstance(value, list):
        return value
    if isinstance(value, dict):
        return list(value.values())
    return []


def count_any(data, keys):
    value = find_first(data, keys)
    return len(as_list(value))


def fetch_serp(keyword, api_key):
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/x-www-form-urlencoded",
        "User-Agent": "curl/8.0.0",
        "Accept": "application/json, text/plain, */*",
    }
    data = {
        "engine": "google",
        "q": keyword,
        "json": "2",
    }
    page = SERP_PAGE.strip()
    num = SERP_NUM.strip()
    if page:
        data["page"] = page
    if num:
        data["num"] = num
    response = requests.post(ENDPOINT, headers=headers, data=data, timeout=60)
    response.raise_for_status()
    return normalize_serp_response(response.json())


def classify_opportunity(paa_count, ads_present, top_domains):
    big_brand_markers = (
        "linkedin.com",
        "indeed.com",
        "canva.com",
        "wikipedia.org",
        "forbes.com",
        "hubspot.com",
    )
    big_site_count = sum(
        1 for domain in top_domains if any(marker in domain for marker in big_brand_markers)
    )
    if paa_count &gt;= 4 and big_site_count &lt;= 2:
        return "High", "Many PAA questions; top results aren’t fully dominated by major sites."
    if ads_present and paa_count &gt;= 3:
        return "Medium", "There is commercial value and some content opportunity."
    if big_site_count &gt;= 4:
        return "Low", "Many major sites in top results; difficult for new sites to enter."
    return "Medium", "Some opportunity; assess further with competitor pages."


def analyze_keyword(keyword, api_key):
    serp = fetch_serp(keyword, api_key)
    organic_results = as_list(
        find_first(serp, ("organic_results", "organic", "organicResults"))
    )
    paa = as_list(
        find_first(serp, ("people_also_ask", "related_questions", "peopleAlsoAsk"))
    )
    ads = as_list(
        find_first(
            serp,
            (
                "ads",
                "paid_results",
                "top_ads",
                "bottom_ads",
                "sponsored_results",
                "sponsored",
                "ad_results",
                "text_ads",
                "shopping_ads",
            ),
        )
    )
    ads_count = len(ads)
    if ads_count == 0:
        ads_count = (
            count_any(serp, ("top_ads",))
            + count_any(serp, ("bottom_ads",))
            + count_any(serp, ("sponsored_results",))
            + count_any(serp, ("sponsored",))
            + count_any(serp, ("ad_results",))
            + count_any(serp, ("text_ads",))
            + count_any(serp, ("shopping_ads",))
        )

    top_domains = []
    for item in organic_results[:10]:
        if not isinstance(item, dict):
            continue
        link = item.get("link") or item.get("url") or item.get("href") or ""
        domain = get_domain(link)
        if domain:
            top_domains.append(domain)

    opportunity_level, recommendation = classify_opportunity(
        len(paa), ads_count &gt; 0, top_domains
    )

    analysis_row = {
        "keyword": keyword,
        "organic_count": len(organic_results),
        "paa_count": len(paa),
        "ads_count": ads_count,
        "ads_present": str(ads_count &gt; 0).lower(),
        "top_domains": ", ".join(top_domains[:5]),
        "opportunity_level": opportunity_level,
        "recommendation": recommendation,
    }
    raw_record = {
        "keyword": keyword,
        "organic_results": organic_results,
        "paa": paa,
        "ads": ads,
        "top_domains": top_domains,
        "full_response": serp,
    }
    return analysis_row, raw_record


def main():
    api_key = TALORDATA_API_KEY.strip()
    if not api_key or api_key == "YOUR_TALORDATA_API_KEY_HERE":
        raise SystemExit(
            "Missing API key. Open analyze_serp_opportunities.py and set TALORDATA_API_KEY."
        )

    keyword_path = ROOT / "keywords.csv"
    output_path = ROOT / "serp_opportunities.csv"
    raw_output_path = ROOT / "serp_raw_records.jsonl"

    with keyword_path.open("r", encoding="utf-8-sig", newline="") as f:
        keywords = [row["keyword"].strip() for row in csv.DictReader(f) if row["keyword"].strip()]

    rows = []
    raw_records = []
    for keyword in keywords:
        print(f"Analyzing: {keyword}")
        row, raw_record = analyze_keyword(keyword, api_key)
        rows.append(row)
        raw_records.append(raw_record)

    fieldnames = [
        "keyword",
        "organic_count",
        "paa_count",
        "ads_count",
        "ads_present",
        "top_domains",
        "opportunity_level",
        "recommendation",
    ]
    try:
        handle = output_path.open("w", encoding="utf-8-sig", newline="")
    except PermissionError:
        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
        output_path = ROOT / f"serp_opportunities_{stamp}.csv"
        handle = output_path.open("w", encoding="utf-8-sig", newline="")
        print(f"serp_opportunities.csv is locked. Writing to {output_path.name} instead.")

    with handle as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)

    try:
        raw_handle = raw_output_path.open("w", encoding="utf-8")
    except PermissionError:
        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
        raw_output_path = ROOT / f"serp_raw_records_{stamp}.jsonl"
        raw_handle = raw_output_path.open("w", encoding="utf-8")
        print(f"serp_raw_records.jsonl is locked. Writing to {raw_output_path.name} instead.")

    with raw_handle as f:
        for record in raw_records:
            f.write(json.dumps(record, ensure_ascii=False) + "\n")

    print(f"Done: {output_path}")
    print(f"Raw records: {raw_output_path}")


if __name__ == "__main__":
    main()

2026 SERP API Benchmark: TalorData vs SerpApi vs SearchAPI.io vs Serper.dev

Elowen — Thu, 21 May 2026 11:33:47 +0000

Choosing a SERP API should not only be based on price. For SEO tools, rank tracking systems, AI Agents, market intelligence products, and data pipelines, data such as success rate, real cost, latency, field completeness, output format, as well as region, language, and device support is also very important.

This article compares four SERP API providers: TalorData, SerpApi, SearchAPI.io, and Serper.dev. The comparison includes official public pricing and free quota, output formats, actual test results, strengths, and weaknesses.

Pricing and Free Quota Comparison

Provider	Free Quota	Starting Plan	Lowest Price Plan
TalorData	1,000 responses	$27 / 30,000 responses	$0.25 / 1k responses
SerpApi	250 responses	$25 / 1,000 searches	$7.5 / 1k searches
SearchAPI.io	100 responses	$40 / 10,000 searches	$1 / 1k searches
Serper.dev	2,500 responses	$50 / 50,000 credits	$0.3 / 1k credits

Note: Prices and free quotas are organized based on publicly available official information. Actual charges may be affected by request type, query depth, failed-request rules, plans, and account settings. Before formal procurement, the billing dashboard of each provider should be used as the source of truth.

Test Situation Comparison

Provider	Success Rate	Average Latency	P50 Latency	P95 Latency	Average Organic Results
TalorData	100%	5770.03 ms	4 001.65 ms	1 0 857.14 ms	8.42
SerpApi	100%	3817.22 ms	3219.75 ms	9060.71 ms	7.87
SearchAPI.io	100%	5487.92 ms	3696.43 ms	10565.20 ms	7.86
Serper.dev	100%	2023.87 ms	1654.01 ms	3428.33 ms	9.70

Strengths and Weaknesses of Each Provider

1. TalorData

TalorData is a SERP API focused on cost efficiency. It supports Google, Bing, Yandex, and DuckDuckGo, supports JSON / HTML output, geo-targeting, and pay-per-successful-request billing.

Strengths:

The pricing is competitive, starting from $0.90 / 1,000 responses, and can go as low as $0.25 / 1,000 responses at high volume.
It supports multiple search engines, including Google, Bing, Yandex, and DuckDuckGo.
It supports JSON and HTML output formats, making it suitable for structured data and custom parsing scenarios.

Weaknesses:

In this test, the average latency was higher than SerpApi and Serper.dev.
Compared with SerpApi, its public market awareness and historical ecosystem are still newer.
Before formal large-scale use, it should still be verified using your own keywords, regions, languages, and device combinations.

2. SerpApi

SerpApi is a mature SERP API provider. Its official documentation covers many result types such as Google organic results, local results, ads, knowledge graph, answer box, images, news, shopping, and videos.

Strengths:

The documentation is mature, the structured JSON response format is clear, and the developer integration experience is relatively good.
It supports JSON and HTML output capabilities, making it suitable for projects that need a mature SERP structure.
It covers many Google SERP features, and its ecosystem and use cases are relatively mature.

Weaknesses:

In this comparison, the starting price is the highest, $25 / 1,000 searches.
The free quota is smaller than TalorData and Serper.dev.
The monthly plan model may not be the most flexible for teams with unstable or low-frequency request volume.

3. SearchAPI.io

SearchAPI.io is positioned as a SerpApi-style alternative. Its official website emphasizes multiple search engines, multiple vertical searches, pay-per-successful-request billing, geo-targeting, and proxy capabilities.

Strengths:

It supports structured JSON and provides response metadata such as html_url / json_url.
In this test, ads, local pack, and images coverage performed relatively prominently.
The official pay-per-success model helps control failed-request costs.

Weaknesses:

Its free quota is the smallest among the four providers, with only 100 free requests.
The starting price is higher than TalorData and Serper.dev.
In this test, the average latency was higher than SerpApi and Serper.dev.

4. Serper.dev

Serper.dev is a lightweight Google Search API, commonly used for AI Agents, RAG, real-time search, and fast integration scenarios. Its official website emphasizes 2,500 free queries, no credit card required, and simple top-up pricing.

Strengths:

In this test, the average latency, P50 latency, and P95 latency were the lowest.
The free quota is relatively high, offering 2,500 free queries.
The pricing model is simple, with a starting plan of $50 / 50,000 credits.

Weaknesses:

The output format mainly focuses on structured JSON and does not emphasize HTML output.
In this test, the PAA coverage rate was 0%.
If deep SEO features are needed, such as PAA, local pack, ads, or HTML output, it needs to be further compared with other providers.

Recommendations for Different Use Cases

Use Case	Recommended Provider	Reason
Lowest-cost SERP testing	TalorData	The starting unit price and high-volume unit price are both competitive, and the free quota is suitable for initial testing.
AI Search / RAG	Serper.dev	The latency is the lowest, the API is simple, and the free quota is relatively high.
Ads / Local Pack / Images coverage	SearchAPI.io	These field categories had relatively prominent coverage in this test.
JSON + HTML output	TalorData, SerpApi, SearchAPI.io	All three provide JSON and HTML or HTML URL related capabilities.
Multi-search-engine SERP data	TalorData, SearchAPI.io	Both emphasize multi-search-engine coverage.

The final choice should not only be based on reviews. A more reliable approach is to retest with your own keywords, regions, languages, devices, and target fields, and then combine the backend actual charges to calculate the real cost per 1,000 usable results.

References

TalorData SERP API: https://www.talordata.com/products/serp-api

SerpApi Pricing: https://serpapi.com/pricing

SerpApi Google Search API: https://serpapi.com/search-api

SearchAPI.io Pricing: https://www.searchapi.io/pricing

SearchAPI.io Google Docs: https://www.searchapi.io/docs/google

Serper.dev: https://serper.dev/

2026 SERP API Comparison: SerpApi vs TalorData, DataForSEO, Serper.dev, SearchAPI.io, Bright Data and More

Elowen — Wed, 20 May 2026 12:51:34 +0000

Choosing a SERP API is not just about price.

For SEO tools, rank tracking systems, AI agents, market intelligence products, or large-scale search data pipelines, the key evaluation points are:

API stability
Parsed SERP data completeness
Country, language, and device support
Failed request billing policy
Documentation quality
Production workload support

This article compares several SERP API providers, including TalorData, DataForSEO, SerpApi, Serper.dev, SearchAPI.io, Bright Data, Oxylabs, SERPHouse, and serpstack.

This is a public-information-based comparison. For any SERP API provider, the final decision should be based on testing real keywords, countries, devices, and result types.

Providers Covered

Provider	Positioning
TalorData	Cost-effective SERP API with multi-search-engine support
DataForSEO	SEO data API for rank tracking and SEO workflows
SerpApi	Google SERP API with mature documentation
Serper.dev	Lightweight Google Search API, commonly used for AI agents
SearchAPI.io	SerpApi-style alternative with multiple search engines
Bright Data	Enterprise-grade SERP API and proxy infrastructure
Oxylabs	Enterprise web scraping and SERP data provider
SERPHouse	Lower-cost SERP API option
serpstack	Entry-level Google SERP API

What Matters When Choosing a SERP API

Criterion	Why It Matters
Search engine support	Google may not be enough if Bing, Yandex, Yahoo, DuckDuckGo, or Baidu are required
SERP feature coverage	People Also Ask, featured snippets, local pack, ads, shopping results, news, images, videos, AI Overview
Geo and language targeting	Important for local SEO and international rank tracking
Mobile vs desktop results	Rankings and SERP layouts can differ by device
Parsed JSON quality	Reduces engineering work and fragile parsing logic
Raw HTML access	Useful for debugging and custom parsing
Success rate	Failed requests can make low prices misleading
Latency	Important for real-time AI and user-facing applications
Pricing model	Per request, per successful response, per result, monthly credits, or pay-as-you-go
Failed request billing	A major hidden cost if not clearly defined
Documentation and SDKs	Affects integration speed and maintenance cost

1. TalorData

TalorData SERP API is a cost-effective SERP API provider for search result data.

According to its public product pages, TalorData supports:

Google
Bing
Yandex
DuckDuckGo
JSON and HTML responses
Geo-targeting
Structured SERP data
Free trial credits

TalorData’s public pricing is competitive compared with many established SERP API vendors. Its website shows pricing as low as $0.25 per 1,000 responses at higher volumes.

Strengths

Area	Assessment
Pricing	Competitive based on public pricing
Search engine coverage	Google, Bing, Yandex, DuckDuckGo
Free trial	Useful for testing real workloads before purchase
Use cases	SEO, AI search, market intelligence, monitoring
Cost-sensitive workloads	Strong fit

Evaluation Path

TalorData can be evaluated using the free quota from the official website.

Suggested test dimensions:

Target keywords
Countries and languages
Desktop and mobile searches
Google, Bing, Yandex, or DuckDuckGo queries
SERP features such as organic results, ads, People Also Ask, local pack, news, images, and shopping results
Required output format, such as JSON or raw HTML

This allows teams to test TalorData against production-like workloads before scaling usage.

2. DataForSEO

DataForSEO provides APIs for SERP data and broader SEO workflows.

Its API ecosystem includes:

SERP data
Keyword data
Backlinks
On-page SEO
Business data
App data
Merchant data

This makes it suitable for SEO platforms, rank trackers, and data products.

Strengths

Area	Assessment
SEO workflows	Strong
Product ecosystem	Broad
Pricing model	Pay-as-you-go
Production use	Suitable for recurring SEO data workloads
Data coverage	Covers multiple SEO-related data categories

Considerations

DataForSEO pricing can require careful modeling. Different endpoints, request modes, locations, and result depths can affect final cost.

Best For

Rank tracking platforms
Keyword research tools
SEO dashboards
Competitive intelligence products
Agencies running repeated search data jobs

3. SerpApi

SerpApi is an established provider for structured Google SERP data.

It supports many Google search surfaces and provides a predictable JSON interface for developers.

Strengths

Area	Assessment
Documentation	Strong
Developer experience	Strong
Google SERP coverage	Mature
Ecosystem familiarity	High
Response structure	Predictable JSON format

Considerations

SerpApi is usually not the cheapest option, especially at scale.

Large-volume workloads should compare total cost against DataForSEO, TalorData, SearchAPI.io, and other lower-cost providers.

Best For

Applications that need structured Google SERP data
Teams that value documentation and predictable response structure
Products where engineering time is a major factor

4. Serper.dev

Serper.dev is commonly used by developers building AI agents, RAG systems, and lightweight search integrations.

It focuses on simple Google search access and fast integration.

Strengths

Area	Assessment
AI agent use cases	Strong
Integration speed	Strong
Simplicity	Strong
Lightweight search	Strong
Developer friendliness	High

Considerations

Serper.dev is not always the best fit for deep SEO analysis.

For detailed SERP feature extraction, local pack fields, ranking precision, shopping results, ads, or advanced SEO-specific data, compare it with DataForSEO, SerpApi, SearchAPI.io, and TalorData.

Best For

AI agents
RAG pipelines
Research assistants
Lightweight web search features
Applications that need fast search context rather than full SEO data

5. SearchAPI.io

SearchAPI.io is positioned as a modern alternative to SerpApi.

It supports multiple search engines and search verticals, including Google search surfaces, Bing, Baidu, DuckDuckGo, Yahoo, and Yandex, depending on the endpoint.

Strengths

Area	Assessment
Multi-engine support	Strong
SerpApi-style interface	Strong
Search verticals	Broad
Developer experience	Good
Use case flexibility	High

Considerations

Exact SERP feature support should be tested for each use case.

Important fields to verify include:

Ads
Shopping results
Local pack
Maps results
People Also Ask
Featured snippets
News
Images
AI-generated search features

Best For

Teams comparing alternatives to SerpApi
Multi-engine search data products
Applications that need several Google verticals
Search monitoring systems

6. Bright Data

Bright Data SERP API is an enterprise-grade SERP API provider.

Bright Data provides scraping infrastructure, proxy networks, automation tools, and global targeting capabilities.

Strengths

Area	Assessment
Enterprise readiness	Strong
Scale	Strong
Global targeting	Strong
Infrastructure	Strong
Support	Enterprise-focused

Considerations

Bright Data is usually not the lowest-cost option for smaller teams.

Its strengths are most relevant for reliability, high concurrency, complex geo-targeting, and enterprise support.

Best For

Large-scale search intelligence
Enterprise data pipelines
High-concurrency workloads
Global SERP monitoring
Teams with strict reliability requirements

7. Oxylabs

Oxylabs provides enterprise web scraping and SERP data services.

It is suited for teams that prioritize infrastructure quality, reliability, and large-scale extraction.

Strengths

Area	Assessment
Enterprise infrastructure	Strong
Scraping reliability	Strong
Proxy network	Strong
Large-scale workloads	Strong
Support	Enterprise-focused

Considerations

Cost and complexity may be higher than what small teams need.

Best For

Enterprise scraping programs
Search intelligence platforms
Large data acquisition teams
Teams that need managed scraping infrastructure

8. SERPHouse

SERPHouse is a lower-cost SERP API provider that supports search engines such as Google, Bing, and Yahoo.

Strengths

Area	Assessment
Pricing	Competitive
Basic SERP API needs	Suitable
Search engine coverage	Google, Bing, Yahoo
Trial availability	Useful

Considerations

Advanced SERP feature parsing, high concurrency, and large production workloads should be benchmarked before production use.

Best For

Cost-sensitive projects
Basic SERP scraping
Small SEO tools
Initial experiments

9. serpstack

serpstack is an entry-level Google SERP API.

Strengths

Area	Assessment
Simple Google SERP access	Suitable
Entry-level usage	Suitable
Basic integration	Straightforward

Considerations

Advanced SEO workflows, large-scale rank tracking, and complex SERP feature parsing may require more specialized providers.

Best For

Small projects
Prototypes
Low-volume SERP needs
Simple Google search result integrations

Comparison Summary

Provider	Best For	Main Strength	Main Consideration
TalorData	Low-cost SERP testing	Competitive pricing	Use the free quota to test real workloads
DataForSEO	SEO platforms	Broad SEO data ecosystem	Pricing needs careful modeling
SerpApi	Structured Google SERP parsing	Documentation and response quality	Not always cheapest
Serper.dev	AI agents and RAG	Simple and fast integration	Less SEO-specialized
SearchAPI.io	SerpApi alternative	Multi-engine and vertical coverage	Validate exact fields
Bright Data	Enterprise scale	Infrastructure and global targeting	Higher cost
Oxylabs	Enterprise scraping	Reliability and proxy infrastructure	Higher cost and complexity
SERPHouse	Budget SERP API	Low-cost option	Benchmark before production use
serpstack	Simple projects	Easy Google SERP access	Limited for advanced use cases

Recommendations by Use Case

Use Case	Recommended Providers
SEO rank tracking	DataForSEO, SerpApi, SearchAPI.io, TalorData
Low-cost SERP collection	TalorData, SERPHouse, DataForSEO
AI agent web search	Serper.dev, TalorData, SearchAPI.io
Enterprise SERP monitoring	Bright Data, Oxylabs
Multi-search-engine coverage	SearchAPI.io, TalorData, SERPHouse
Google SERP JSON quality	SerpApi, SearchAPI.io, DataForSEO
Prototyping	Serper.dev, serpstack, TalorData

Final Verdict

There is no single best SERP API for every team.

How to Compare Two SERP Snapshots and Detect Ranking Changes

Elowen — Mon, 18 May 2026 08:27:12 +0000

If you are building a keyword rank tracker, collecting SERP data is only the first step.

The useful part is detecting what changed between two search result snapshots.

For example:

Did a page move from position 8 to position 3?
Did a competitor enter the top 10?
Did a URL disappear from page one?
Did the same domain rank with a different page?

What to store in a snapshot

A SERP snapshot should include both the results and the search context.

{
  "query": "search api",
  "engine": "google",
  "device": "desktop",
  "country": "us",
  "checked_at": "2026-05-18T08:00:00Z",
  "results": [
    {
      "position": 1,
      "title": "Example result",
      "url": "https://example.com/page",
      "domain": "example.com"
    }
  ]
}

Do not compare two snapshots unless the context matches:

query
engine
device
country or location

Otherwise, the ranking change may be caused by a different search context, not by SEO movement.

Compare by URL and domain

You usually need two views.

URL-level comparison answers:

Did this exact page move?

Domain-level comparison answers:

Is this website still visible, even if a different page ranks?

Example:

Yesterday: example.com/old-page at position 5
Today: example.com/new-page at position 6

At URL level:

old-page dropped
new-page is new

At domain level:

example.com moved from 5 to 6

Both are useful.

Basic change types

For each URL or domain, classify the change as:

new
dropped
moved_up
moved_down
unchanged

Use this delta formula:

delta = previous_position - current_position

So:

8 -> 3 = +5
3 -> 8 = -5

Positive means the result improved.

Example change report

{
  "query": "search api",
  "engine": "google",
  "device": "desktop",
  "country": "us",
  "changes": [
    {
      "type": "moved_up",
      "url": "https://example.com/page",
      "domain": "example.com",
      "previous_position": 8,
      "current_position": 3,
      "delta": 5
    },
    {
      "type": "new",
      "url": "https://competitor.com/page",
      "domain": "competitor.com",
      "previous_position": null,
      "current_position": 7,
      "delta": null
    }
  ]
}

Store snapshots, not only diffs

Do not store only the ranking changes.

Store the full snapshots first, then calculate diffs from them.

That makes it easier to:

reprocess old data
fix comparison bugs
change URL normalization rules
audit strange ranking changes
generate new reports later

A simple data model is:

serp_snapshots
serp_results
serp_changes

The serp_changes table can always be regenerated.

Common mistakes

The most common mistakes are:

comparing different devices
comparing different countries
not normalizing URLs
tracking only one domain
mixing URL-level and domain-level changes
using confusing delta direction
storing only diffs

Takeaway

A reliable SERP change detector needs more than yesterday’s position minus today’s position.

You need consistent search context, URL normalization, URL-level comparison, domain-level comparison, and full snapshot storage.

Once those are in place, ranking changes become much easier to explain.

What Role Does a Search API Play in AI/RAG Workflows?

Elowen — Tue, 12 May 2026 08:37:41 +0000

RAG systems need good retrieval before they can generate useful answers.

Most examples focus on vector databases, embeddings, and chunking. Those are important, but there is another layer that often gets overlooked:

How do you find fresh, relevant web sources in the first place?

That is where a Search API can help.

In an AI or RAG workflow, a Search API is usually used before crawling, embedding, or summarizing. It can provide structured search results for a user query, topic, company, product, or keyword.

A typical flow looks like this:
User query

Search API
Relevant URLs
Fetch page content
Clean and chunk text
Embed or summarize
Generate answer

This is useful when the system needs information that changes often, such as:

market research
competitor monitoring
product comparisons
news discovery
SEO research
brand monitoring
lead research
topic discovery

A Search API does not replace a vector database. It solves a different problem.

The vector database helps retrieve from content you already collected.

The Search API helps discover external content you may not have yet.

For many AI agents, this matters because the web is constantly changing. If the retrieval layer only uses old internal documents, the output can become stale.

A good search layer should return enough structured data to decide what to fetch next:

title
URL
snippet
position
search engine
location
language
timestamp

For some workflows, raw HTML or screenshots can also help with verification.

The main benefit is that the AI system can start from structured search results instead of relying on fragile scraping logic or manual URL lists.

In short:
Search API = discovery layer
Crawler = content collection layer
Vector database = memory layer
LLM = reasoning and generation layer

If your RAG system needs fresh web information, the search layer is worth designing carefully.

How to Get Google, Bing, and Yandex Search Results as JSON

Elowen — Sat, 09 May 2026 07:56:40 +0000

Search result data is useful for many developer and SEO workflows:

rank tracking
keyword research
competitor monitoring
market research
SEO tools
internal data pipelines
automation workflows

You can build your own scraper for this, but maintaining it usually means dealing with proxies, retries, browser rendering, parser updates, rate limits, anti-bot systems, and monitoring.

For many projects, it is simpler to use a Search API and get structured results back directly.

In this post, I’ll show a basic example using TalorData, a Search API that supports Google, Bing, and Yandex.

It can return:

JSON
raw HTML
screenshots

There are 1,000 free requests, and no credit card is required.

Website
Playground

Example: Get Google SERP Data as JSON

Here is a basic curl request:

curl -X POST 'https://serpapi.talordata.net/serp/v1/request' \
  -H 'Authorization: Bearer YOUR_API_TOKEN' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'engine=google' \
  -d 'q=search api' \
  -d 'json=2'

The request includes:

engine=google: the search engine
q=search api: the search query
json=2: return structured JSON output

TalorData also supports Bing and Yandex, so you can change the engine parameter depending on the search source you need.

Example Response Shape

The API returns structured data that you can use in an app, dashboard, report, or data pipeline.

A simplified response shape might look like this:

{
  "search_metadata": {
    "engine": "google",
    "query": "search api"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example Result",
      "link": "https://example.com",
      "snippet": "Example search result snippet."
    }
  ]
}

Python Example

import requests

url = "https://serpapi.talordata.net/serp/v1/request"

headers = {
    "Authorization": "Bearer YOUR_API_TOKEN",
    "Content-Type": "application/x-www-form-urlencoded"
}

data = {
    "engine": "google",
    "q": "search api",
    "json": "2"
}

response = requests.post(url, headers=headers, data=data)
response.raise_for_status()

result = response.json()

print(result)

JavaScript Example

const response = await fetch("https://serpapi.talordata.net/serp/v1/request", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_TOKEN",
    "Content-Type": "application/x-www-form-urlencoded"
  },
  body: new URLSearchParams({
    engine: "google",
    q: "search api",
    json: "2"
  })
});

if (!response.ok) {
  throw new Error(`Request failed: ${response.status}`);
}

const result = await response.json();

console.log(result);

When to Use a Search API Instead of Building a Scraper

A Search API is usually a better fit when:

you need structured SERP data quickly
you do not want to maintain proxies
you need location or country-specific search results
you need JSON output for an app or workflow
scraping infrastructure is not your core product

Building your own scraper can still make sense if you need complete control, very custom behavior, or already have scraping infrastructure in place.

Common Use Cases

Search result APIs are often used for:

SEO rank tracking
keyword research
competitor analysis
brand monitoring
market research
AI and data enrichment workflows
internal dashboards

Final Thoughts

Search result scraping looks simple at first, but production systems usually require much more than one HTTP request.

Using a Search API can reduce the amount of infrastructure you need to maintain and let you focus on the data and product experience.

If you try TalorData, I’d be interested in feedback on:

response fields
output formats
pricing
playground usability
missing parameters

DEV Community: Elowen

What Data Should a SERP Result Actually Include?

Best SERP APIs Compared: 1,009-Query Benchmark

1. Overall Ranking

2. Result Completeness

3. Core Field Completeness

4. Enriched Field Completeness

5. SERP Feature Coverage

6. AI Use-Case Performance

7. Precision / Recall / F1

8. Cross-Platform Consistency

9. Query Type Impact on Consistency

10. Use-Case Selection Guide

11. Conclusion

How to build a Google rank tracker with TalorData (Python)

Get a token

First request

Parse it in Python

Find a target domain's rank

Track a list of keywords over time

Chart

Wrapping up

Talordata: A Multi-Engine SERP API for Google, Bing, Yandex

What is Talordata

Core Features

Pricing

Quick Start

Why Talordata

How to Get Google Search Results as JSON

What We Are Building

Use Cases

API Request Example

Request Parameters

Python Example

Extract Organic Results

Save Results to a CSV File

Full Python Script

What You Can Do Next

Common Issues

1. Invalid API Key

2. Empty Results

3. Timeout

Conclusion

I Used a SERP API to Validate an AI Resume Builder Idea

What You Will Get at the End

Step 1: Turn the Idea into Searchable Keywords

Step 2: Where the Keywords Come From

1. Break Down the Core Features

2. Expand with User Modifiers

3. Add Keywords from Search Suggestions and Existing Pages

Step 3: Create keywords.csv

Step 4: Query Keywords with the TalorData SERP API

Step 5: Run the Script and Generate the Result Table

Step 6: Look at the Result Table Before Judging the Opportunity

Step 7: How to Decide Whether a Signal Is Strong or Weak

Step 8: Turn the Result into a Conclusion

Step 9: Create Your Opportunity Decision Table

Optional: Turn the Rules into a Simple Score

Step 10: Apply the Method to Your Own Project

Conclusion

2026 SERP API Benchmark: TalorData vs SerpApi vs SearchAPI.io vs Serper.dev

Pricing and Free Quota Comparison

Test Situation Comparison

Strengths and Weaknesses of Each Provider

1. TalorData

2. SerpApi

3. SearchAPI.io

4. Serper.dev

Recommendations for Different Use Cases

References

2026 SERP API Comparison: SerpApi vs TalorData, DataForSEO, Serper.dev, SearchAPI.io, Bright Data and More

Providers Covered

What Matters When Choosing a SERP API

1. TalorData

Strengths

Evaluation Path

2. DataForSEO

Strengths

Considerations

Best For

Step 3: Create `keywords.csv`