TalorData SERP API

I run a small SaaS and I wanted to track my keyword rankings.

I didn't want to pay $100/month for an SEO tool that I'd only use for one thing.

So I decided to build my own rank tracker.

The first version was a scraper. It worked for a week. Then Google changed something and everything broke.

This is the story of how I rebuilt it properly — using Python and a SERP API — and ended up with a system that can scale to thousands of keywords.

I'm sharing the code and architecture so you can build your own.

The Problem

I needed to track rankings for about 200 keywords across 3 websites.

My first attempt was a simple Python script using requests and BeautifulSoup.

Here's what happened:

Week 1: It worked perfectly.

Week 2: Google changed their HTML layout. My parser stopped working.

Week 3: I fixed the parser. Then I hit CAPTCHAs.

Week 4: I added proxies. Then I realized search results differ by location.

Week 5: I gave up and started looking for a better solution.

The Solution

I switched to a SERP API approach.

Instead of scraping Google, I send structured requests and receive structured JSON:

python

import os import requests API_TOKEN = os.getenv("TALOR_API_TOKEN") API_URL = "https://serpapi.talordata.net/serp/v1/request" def google_search(keyword): headers = {"Authorization": f"Bearer {API_TOKEN}"} payload = {"engine": "google", "q": keyword} response = requests.post(API_URL, headers=headers, json=payload) return response.json()

That's it. No proxies. No parser maintenance. No headaches.

The Architecture

Here's the entire system architecture:

text

Keyword List ↓ SERP API Collector ↓ Ranking Processor ↓ Database ↓ SEO Dashboard

Keyword List: The keywords you want to track. Stored in JSON or database.

SERP API Collector: The code above. Returns structured search results.

Ranking Processor: Extracts ranking positions from the results.

Database: Stores historical data.

SEO Dashboard: Displays charts and reports.

Finding Rankings

The core logic is simple:

python

def find_position(results, domain): organic = results.get("organic_results", []) for item in organic: if domain in item["link"]: return item["position"] return None

Tracking Multiple Keywords

python

keywords = [ "python serp api", "google search api", "seo automation" ] for keyword in keywords: results = google_search(keyword) position = find_position(results, "example.com") print(f"{keyword}: {position}")

The Results

I've been running this system for 3 months now.

What works:

• It runs every morning automatically

• It tracks 200+ keywords

• No maintenance required

• The dashboard shows trends clearly

What I learned:

• Historical data is more valuable than current data

• Location and device parameters matter

• A good API saves months of development time

The Cost

The SERP API costs $0.25 per 1,000 requests.

For 200 keywords tracked daily:

text

200 keywords × 30 days = 6,000 requests/month 6,000 × $0.25/1,000 = $1.50/month

That's less than one cup of coffee. Compared to $100/month for a commercial SEO tool, it's a huge saving.

Resources

• TalorData SERP API: https://www.talordata.com/

• Python SDK: https://github.com/Talordata/talordata-serp-python

• Full tutorial: https://www.talordata.com/blog/google-rank-tracker-python-serp-api

Originally published on the TalorData Blog.

A story about platform risk, fast content, and why honesty converted better than features.

In August 2025, Microsoft retired every official Bing Search API. No successor, no migration path — the endpoints just died.

I run TalorData, a small SERP data API (four engines: Google, Bing, Yandex, DuckDuckGo; pay-per-success pricing). When the retirement hit, my first feeling wasn’t opportunism, honestly — it was a mix of “this is terrible for those teams” and “some of them are going to need what we sell.”

That tension is where this post lives. A year later, here’s what happened, what worked, and what I’d tell other indie founders about the weird acquisition channel called someone else’s platform risk.

The scramble

Within days of the shutdown, developers started showing up with the same three questions:

1. Can I scrape Bing myself instead? (You can try. Fingerprinting and CAPTCHAs will win at scale.)

2. Should I just drop Bing? (Sometimes yes — but SEO tools serving agencies couldn’t.)

3. Who still provides structured Bing results? ← this one became our entire funnel.

What surprised us: plenty of teams didn’t discover the breakage until weeks later. Nothing threw errors. Their fallback paths silently returned empty data, dashboards looked “a bit thin,” agents cited stale sources. Silent degradation is stickier content than any ad we could write.

What we did — and what actually moved the needle

We’re a tiny team, so we couldn’t outspend anyone. We did three things, roughly in order of ROI:

1. Published a migration guide immediately. Not polished — just the field mapping from old Bing v7 responses to modern SERP API formats, plus working code. Almost nobody had written this yet, so it ranked for exactly the searches desperate people were making at 2 AM. Speed beat polish by a mile.

2. Answered questions honestly, including “you might not need us.” In comment sections and forums, we told solo builders that scraping was fine for one-off tasks, and that generic LLM search integrations were good enough for vague context needs. Sounds counterproductive. It wasn’t — the teams that did need structured results trusted us precisely because we didn’t pretend everyone did.

3. Made the alternatives legible. Comparison pages, real pricing math, latency numbers. When someone’s pipeline is bleeding, clarity is the conversion mechanism.

The result pattern over the year: steady inbound from teams hitting the wall mid-breakage, not a spike-and-fade. Retirement-driven demand turns out to have a long tail — some customers found us months later while auditing dependencies.

Four lessons for other founders

Platform risk is a content calendar. Every major API retirement, deprecation, or price hike creates a burst of confused buyers searching for answers. Being genuinely useful during the confusion window is the cheapest qualified traffic that exists. You don’t gloat; you show up with the map.

Audit your own dependencies before preaching. Writing the migration guide forced us to ask: which upstreams could kill us tomorrow? We’ve since documented ours internally. If your product sits on someone else’s API, you’re one terms-of-service update away from the same blog post — written about you.

Honesty scales better than hype in developer markets. The “when you shouldn’t use us” paragraph appears in all our content. It costs us some signups and earns us the rest.

Silent failures are your marketing window. Teams that noticed instantly already had a plan. The ones who found us were the ones whose monitoring stayed green while their data went stale. Content that helps people detect the problem (“go check what your pipeline calls for search results”) reaches further than content that sells the solution.

Where things stand

A year on, Bing remains a first-class engine for us — ironically more differentiated now than before, since the official option is gone and every provider still offering it has to maintain the collection infrastructure themselves.

If you’re building something that consumes search results and want to see what structured multi-engine data looks like, our door’s here: talordata.com. Free responses come with signup, no subscription attached.

And if you’ve lived through a platform retirement that hit your product — I’d genuinely like to hear how you handled it in the comments.

Something odd kept happening before we built TalorData.

We'd talk to teams running SEO platforms — solid businesses, thousands of users. Their backend looked the same everywhere: a keyword database, a scheduled crawler pulling rankings every few hours, dashboards rendered on top. Built for a human analyst who checks numbers once a morning.

Then their users started typing questions into a chat box.

"Why did my article lose rankings this week?" "Which competitor just jumped above me for this keyword?"

And suddenly their architecture fell apart. The LLM behind their shiny AI feature couldn't pull an answer from a database last refreshed six hours ago, and couldn't parse raw HTML anyway. The data layer was built for reporting; the product had become a conversation.

That gap is why we built TalorData — a real-time SERP API that returns structured JSON from Google, Bing, Yandex, and DuckDuckGo. No proxy pools, no CAPTCHA solving, no headless browsers on the customer's side. p90 under 0.8s, flat $0.25 per 1,000 responses, 500 free credits on signup so devs can benchmark before paying.

The honest part: we don't replace DataForSEO-class providers for everyone. If you need historical keyword volumes, backlink indexes, bulk rank tracking across 100k domains — those databases took a decade to build and they're still the right tool. We're going after the newer workload: agents, RAG pipelines, and monitoring tools where the "consumer" of search results is a model, not a person scrolling a dashboard.

The broader lesson for anyone building infrastructure: watch for the moment the consumer of your data changes. Ours changed from human analysts to machines. When that happens, everything downstream — freshness requirements, output format, acceptable latency, even pricing model — has to be re-decided from zero. Incumbents rarely do it fast, because their existing customers haven't asked yet.

If you're wiring live search into something, come benchmark us: https://talordata.com

I run TalorData, a SERP API for developers. The classic indie problem: building a good API is the easy part. Getting developers to actually discover it, integrate it, and trust it enough to pay for it — that's the whole game.

The insight

Developers don't search for "SERP API" on a Tuesday afternoon. They search for solutions to a problem they're already having: "my AI agent is giving me stale answers," "my scraper keeps getting blocked," "I need location-filtered search results and I don't want to maintain proxies."

So instead of waiting for them to find me, I went where their agents already live — and I gave away the integration.

The move

I open-sourced a plugin for Hermes Agent (Nous Research's open-source agent) that plugs straight into my API:

- It replaces Hermes's web_search backend with TalorData's Google results

- It adds a talor_google_search tool with the full parameter set (device, location, language, tbm, tbs time filters, pagination, and more)

- One token, native integration, no server to run — and the response is normalized so it doesn't bloat the agent's context

Why open source works for a paid API:

1. It's a live demo. Installing a plugin is more convincing than any landing page. The moment someone runs their first location-filtered search, the product sells itself.

2. It rides existing communities. Agent frameworks have big, active ecosystems (GitHub, Reddit, Discord, Telegram). Shipping native plugins gets you into those conversations without running ads.

3. Free tier = low-risk entry. 500 free API responses on signup is enough to wire a working demo. The first paid step is a natural upsell once the value is obvious.

4. Contributions become product direction. The repo is open — the "Bing / Yandex / DuckDuckGo soon" roadmap literally comes from what users ask for.

What I'd do differently / what I learned

- Ship the plugin before the blog post. The plugin is the proof; the write-up is just the summary.

- Answer real questions on Quora and forums in the format of "here's how to solve your problem," and mention the plugin only where it's genuinely the solution. Indie marketing is about being useful first.

- Track everything. I tag every signup source so I can see which community actually converts.

If you're building an API for developers, the playbook is simple: find where your users already are, build the integration they'd want anyway, and make the first hundred requests free.

Repo: https://github.com/Talordata/talordata-hermes-plugin

Docs: https://docs.talordata.com/serp-api/integration/mcp-integration/hermes-agent-integration

Try it (500 free responses): https://www.talordata.com

If you are building a SaaS product that depends on search data, this is something worth thinking about.

Many products still rely on traditional search APIs for:

- SEO tools

- AI assistants

- Research products

- Monitoring systems

But the requirements have changed.

Modern users don't just want search results.

They want intelligence.

An AI SEO assistant needs to know ranking changes.

A research agent needs real-time information.

A content tool needs competitive search insights.

This means developers need more than URLs and snippets.

They need structured SERP data.

The infrastructure layer is becoming just as important as the AI model itself.

Instead of spending engineering time maintaining:

- scraping infrastructure

- proxy rotation

- parsing systems

teams can focus on the product experience.

The opportunity is that search is becoming a data infrastructure problem.

For founders building AI products, reliable search access will become a competitive advantage.

Curious how others are solving this?

Why We Built TalorData

We were building AI agents and kept hitting the same wall: search data was too slow, too messy, and too expensive.

Existing SERP APIs were built for dashboards, not agents. They took 2–4 seconds to respond. They returned HTML that needed parsing. They charged for failed requests.

We spent months managing proxy pools and fixing broken selectors. Eventually we said: “There has to be a better way.”

So we built it.

What We Did Differently

1. Designed for speed

We optimized for P90 < 0.8s. When your agent is waiting, every millisecond matters.

2. Structured data first

No HTML parsing. No regex. Clean JSON with parsed titles, links, descriptions, and positions.

3. Pay only for success

Failed requests cost $0. Your budget aligns with results.

4. One API, four engines

Google, Bing, Yandex, and DuckDuckGo — all through a single endpoint.

The Results

Third‑party benchmarks rank TalorData #1 among six major SERP API providers:

• General Score: 79.19

• Zero‑result rate: 2.08% (lowest)

• Average organic results: 8.85 per query (highest)

And the pricing? $0.25/1K at scale — significantly lower than incumbents.

Integrations

We built native integrations for:

• LangChain (langchain-talor-serp)

• LlamaIndex

• Dify

• n8n

• MCP (Claude, Cursor, VS Code)

What‘s Next

We‘re continuing to expand our integration ecosystem and improve latency. The goal is simple: make search data as easy to use for AI agents as it is for humans.

Try It

500 free requests on sign‑up — no credit card required.

👉 talordata.com

Would love to hear what you‘re building. Drop a comment 👇

The Problem

I‘ve been building AI agents with LlamaIndex, and I kept hitting the same wall: LLMs can’t access current information.

For a research assistant I was building, this was a dealbreaker. Users wanted answers about today‘s news, not 2023 data.

I looked at building my own scraping infrastructure, but that’s a rabbit hole I didn‘t want to go down. Maintaining proxies, parsing HTML, handling CAPTCHAs — life’s too short.

The Solution

I found TalorData SERP API, which provides structured search results from Google, Bing, Yandex, and DuckDuckGo through a single API. They announced official LlamaIndex integration in June 2026, so integration took about 20 minutes.

How It Works

1. Install packages:

bash

pip install llama-index-core llama-index-llms-openai talordata-serp

2. Create the search tool:

python

import os, json from llama_index.core.tools import FunctionTool from talordata_serp import TalorClient client = TalorClient(api_key=os.environ["TALORDATA_API_KEY"]) def search_web(query: str, engine: str = "google", num: int = 5) -> str: response = client.search(q=query, engine=engine, num=num, json=2) results = [ {"title": r.get("title"), "link": r.get("link"), "snippet": r.get("snippet")} for r in response.get("organic_results", [])[:num] ] return json.dumps(results, indent=2) search_tool = FunctionTool.from_defaults( fn=search_web, name="web_search", description="Search the web for real-time information." )

3. Build and run the agent:

python

from llama_index.core.agent import ReActAgent from llama_index.llms.openai import OpenAI llm = OpenAI(model="gpt-4o-mini", temperature=0) agent = ReActAgent.from_tools(tools=[search_tool], llm=llm, verbose=True) response = agent.chat("What's new in AI search engines in 2026?") print(response)

What I‘ve Built With It

Competitor Monitoring Agent

My favorite use case: a LlamaIndex agent that runs daily, searches for my target keywords, and summarizes where competitors are ranking.

It runs on a schedule, costs pennies per day, and saves hours of manual checking.

Other Ideas:

• Research assistants that search before answering

• SEO rank tracking dashboards

• Brand monitoring bots

• News summarization tools

Costs

At $1.00 per 1,000 requests (entry tier, down to $0.25/1K at volume), the economics work:

• 100 searches/day × 30 days = 3,000 requests = ~$3/month

• That‘s less than a coffee for a full competitive intelligence system

The Best Part

The API returns clean, structured JSON — no HTML parsing, no dealing with CAPTCHAs, none of the headaches of maintaining scrapers.

Want to Try It?

Free trial: 1,000 requests at TalorData — no credit card required.

Would love to hear what you‘re building with LlamaIndex! Drop a comment 👇

The Problem

I‘ve been building AI applications with Dify, and I kept hitting the same wall: LLMs can’t access current information.

For a research assistant I was building, this was a dealbreaker. Users wanted answers about today‘s news, not 2023 data.

I looked at building my own scraping infrastructure, but that’s a rabbit hole I didn‘t want to go down. Maintaining proxies, parsing HTML, handling CAPTCHAs — life’s too short.

The Solution

I found TalorData SERP API, which provides structured search results from Google, Bing, Yandex, and DuckDuckGo through a single API.

They already had a Dify plugin, so integration took about 20 minutes.

How It Works

1. Get a TalorData API Token

Sign up, get free trial credits, create a token.

2. Install the Dify Plugin

Search for “TalorData SERP” in the Dify marketplace and install it.

3. Configure and Use

Paste your token, add a Tool node to your workflow, select the search action you need, map your query, and you‘re live.

What I‘ve Built With It

Competitor Monitoring Workflow

My favorite use case: a Dify workflow that runs daily, checks Google and Bing for my target keywords, and summarizes where competitors are ranking.

It runs on a schedule, costs pennies per day, and saves hours of manual checking.

Other Ideas:

• Research assistants that search before answering

• SEO rank tracking dashboards

• Brand monitoring bots

• Local business discovery tools

• E-commerce price monitors

Costs

At $1.00 per 1,000 requests, the economics work:

• 100 keywords/day × 30 days = 3,000 requests = ~$3/month

• That‘s less than a coffee for a full competitive intelligence system

The Best Part

The API returns clean, structured JSON — no HTML parsing, no dealing with CAPTCHAs, none of the headaches of maintaining scrapers.

What’s Next

I‘m planning to build a full SEO dashboard using this setup — Dify workflows feeding data into a simple dashboard, all automated.

Want to Try It?

Free trial: Credits at TalorData SERP API for Dify

Would love to hear what you‘re building with Dify! Drop a comment 👇

The Problem

I‘ve been building AI applications with Dify, and I kept hitting the same wall: LLMs can’t access current information.

For a research assistant I was building, this was a dealbreaker. Users wanted answers about today‘s news, not 2023 data.

I looked at building my own scraping infrastructure, but that’s a rabbit hole I didn‘t want to go down. Maintaining proxies, parsing HTML, handling CAPTCHAs — life’s too short.

The Solution

I found TalorData SERP API, which provides structured search results from Google, Bing, Yandex, and DuckDuckGo through a single API.

They already had a Dify plugin, so integration took about 20 minutes.

How It Works

1. Get a TalorData API Token

Sign up, get 1,000 free requests, create a token.

2. Install the Dify Plugin

Search for “TalorData SERP” in the Dify marketplace and install it.

3. Configure and Use

Paste your token, add a Tool node to your workflow, select the search action you need, map your query, and you‘re live.

What I‘ve Built With It

Competitor Monitoring Workflow

My favorite use case: a Dify workflow that runs daily, checks Google and Bing for my target keywords, and summarizes where competitors are ranking.

It runs on a schedule, costs pennies per day, and saves hours of manual checking.

Other Ideas:

• Research assistants that search before answering

• SEO rank tracking dashboards

• Brand monitoring bots

• Local business discovery tools

• E-commerce price monitors

Costs

At $1.00 per 1,000 requests, the economics work:

• 100 keywords/day × 30 days = 3,000 requests = ~$3/month

• That’s less than a coffee for a full competitive intelligence system

The Best Part

The API returns clean, structured JSON — no HTML parsing, no dealing with CAPTCHAs, none of the headaches of maintaining scrapers.

What’s Next

I‘m planning to build a full SEO dashboard using this setup — Dify workflows feeding data into a simple dashboard, all automated.

Want to Try It?

Free trial: 1,000 requests at TalorData SERP API for Dify

Would love to hear what you‘re building with Dify! Drop a comment 👇

Claude, Cursor, VS Code — all supporting MCP. Tools that support MCP become discoverable across the entire ecosystem.

TalorData now has an MCP server. One integration. Works everywhere.

github.com/Talordata/talordata-mcp