Bing SERP API Shutdown: Best Alternatives 2025

When Microsoft announced significant changes to Bing’s SERP API access in late 2024, it sent shockwaves through the developer community. Free tiers were cut, pricing increased sharply, and many high-volume use cases became cost-prohibitive overnight. Teams running production AI agents and data pipelines suddenly needed a migration path — fast.

We have helped several teams navigate this transition. Here is the honest analysis of the current landscape, including complete migration code and a decision framework for choosing the right replacement.

Key Takeaways

• SearchCans is the best price-performance alternative at $0.56/1K vs Bing’s new commercial pricing — saving 80%+ for high-volume applications
• The correct SearchCans API is POST, not GET — use POST /api/search with a JSON body containing s (query), t (engine), and d (timeout ms). The old Bing SDK GET pattern does not apply
• Parallel Lanes (up to 68 on Ultimate) eliminate hourly throttling — critical for AI agents that make bursty, concurrent search requests
• Always build a provider abstraction layer — the Bing API change is not unique; any single-provider dependency is an infrastructure risk

What Happened to Bing’s SERP API?

Microsoft restructured Bing API access across Q3–Q1 2024–2025:

• Q3 2024: Announced pricing restructuring and access tier changes
• Q4 2024: Free tier significantly reduced; commercial pricing increased by 3–5×
• Q1 2025: Many developers migrated to alternatives; the official Bing Search API remains available but at pricing that makes it impractical for most AI and data pipeline use cases

The changes did not affect all users equally. Low-volume SEO tools with flexible budgets could absorb the increase. High-volume AI agents making millions of calls per month faced either cost ceilings or prohibitive pricing.

The Current Landscape: 2025 SERP API Options

After evaluating the major providers across price, reliability, concurrency model, and developer experience, here is our honest assessment:

Tier 1: Best Overall Value

SearchCans — Recommended

For most developers migrating from Bing, SearchCans is the straightforward replacement: lower cost, superior concurrency model, and a broader API suite.

Tier 2: Established Players

SerpApi

Best if you specifically need exotic search engines (Yandex, Baidu). Not cost-effective for Google/Bing at scale.

Serper

Decent middle-ground option. Rate limits can cause throttling issues for AI agent workloads.

Tier 3: Enterprise Solutions

Bright Data, Oxylabs, and similar providers are enterprise-focused with complex pricing, minimum commitments, and sales-driven onboarding. Appropriate only for large organizations with specific compliance requirements that SearchCans does not cover.

SearchCans is NOT for accessing Yandex, Baidu, or other non-Google/Bing search engines — use SerpApi for those. SearchCans is the right choice for Google and Bing SERP data at scale.

Migration Guide: From Bing API to SearchCans

Step 1: Understand the API Difference

The most common migration mistake is reusing the Bing SDK’s GET-based pattern. SearchCans uses POST /api/search with a JSON body.

Bing SDK pattern (deprecated for your stack):

# OLD: Bing Cognitive Search SDK style — do NOT use this pattern
import requests
response = requests.get(
    "https://api.bing.microsoft.com/v7.0/search",
    headers={"Ocp-Apim-Subscription-Key": BING_KEY},
    params={"q": "query", "count": 10}
)

SearchCans pattern (correct):

# NEW: SearchCans SERP API — POST with JSON body
import requests

def search_google(query: str, api_key: str) -> list:
    """Fetch Google SERP results via SearchCans."""
    headers = {"Authorization": f"Bearer {api_key}"}
    payload = {
        "s": query,      # Search query
        "t": "google",   # Engine: "google" or "bing"
        "d": 10000,      # API timeout in milliseconds (NOT result count)
        "p": 1           # Page number
    }
    resp = requests.post(
        "https://www.searchcans.com/api/search",
        headers=headers,
        json=payload,
        timeout=15
    )
    data = resp.json()
    return data.get("data", []) if data.get("code") == 0 else []

Step 2: Normalize Response Formats

Different APIs return different field names. Build a normalization layer so switching providers requires only one code change:

def normalize_result(raw: dict, source: str) -> dict:
    """Normalize results from different SERP providers to a common schema."""
    if source == "searchcans":
        return {
            "title":   raw.get("title", ""),
            "url":     raw.get("url", ""),
            "snippet": raw.get("description", ""),
        }
    elif source == "serpapi":
        return {
            "title":   raw.get("title", ""),
            "url":     raw.get("link", ""),
            "snippet": raw.get("snippet", ""),
        }
    elif source == "bing":
        return {
            "title":   raw.get("name", ""),
            "url":     raw.get("url", ""),
            "snippet": raw.get("snippet", ""),
        }
    return raw

Step 3: Implement Fallback Logic

Never depend on a single provider. This architecture survived the Bing API change without any user-facing downtime for teams that had it in place:

import asyncio
from typing import Optional

PROVIDERS = [
    {"name": "searchcans", "fn": search_google},
    # Add fallback providers here
]

async def search_with_fallback(query: str) -> Optional[list]:
    """Try providers in order, return first successful result."""
    for provider in PROVIDERS:
        try:
            result = provider["fn"](query, api_key=API_KEYS[provider["name"]])
            if result:
                normalized = [normalize_result(r, provider["name"]) for r in result]
                return normalized
        except Exception as e:
            print(f"[WARN] {provider['name']} failed: {e}")
            continue
    return None

Step 4: Sample SearchCans API Response

A successful call returns:

{
  "code": 0,
  "data": [
    {
      "title": "Bing SERP API Alternatives 2025 — Full Comparison",
      "url": "https://example.com/bing-api-alternatives",
      "description": "Microsoft's Bing Search API changes forced developers to evaluate alternatives...",
      "position": 1
    },
    {
      "title": "SearchCans SERP API — Quick Start Guide",
      "url": "https://www.searchcans.com/docs/",
      "description": "Get structured Google and Bing SERP data with one API call...",
      "position": 2
    }
  ]
}

code: 0 = success. Each result includes title, url, description, and position.

Cost Comparison: Real Numbers

At 500K requests/month — a typical mid-scale AI agent workload:

At 2M requests/month (Ultimate plan, $0.56/1K), SearchCans costs approximately $1,120/month — versus SerpApi at $20,000+/month for the same volume.

Concurrency: Why Parallel Lanes Matter for AI Agents

The Bing API used a requests-per-second limit. Traditional SERP APIs use hourly rate limits. Both models create queuing problems for AI agents that need to fire multiple parallel searches simultaneously.

SearchCans Parallel Lanes model: you are limited by simultaneous in-flight requests, not hourly totals. As long as a lane is available, requests go through 24/7.

Lessons Learned from API Provider Transitions

After helping teams navigate multiple API transitions (Bing, Google’s 10k/day free tier, Twitter/X API changes):

1. Never rely on a single provider — APIs change, companies pivot, pricing increases
2. Abstract your integrations from day one — the normalization layer above takes 30 minutes to build and saves weeks during migrations
3. Monitor costs per provider actively — $0.004 per request differences become significant at millions of calls
4. Cache aggressively — repeated queries (brand monitoring, competitor tracking) can achieve 40–60% cache hit rates with a 1-hour TTL
5. Test your fallback — if you never test provider failure, your fallback logic will have bugs when you actually need it

Pro Tip: Run a parallel A/B test with both your old Bing integration and the new SearchCans endpoint for at least two weeks before full cutover. Map every field your application consumes from Bing’s response schema to the SearchCans equivalent — the response structures differ. In our migration support work, teams that did field-by-field schema mapping before cutover completed migrations in 2–3 days; those who skipped this step averaged 2–3 weeks of production debugging.

⚠️ Common Pitfall: Conflating Bing’s SERP API retirement with the Bing Autosuggest and Entity Search APIs, which had different deprecation timelines. Verify exactly which Bing API endpoints your application calls before assuming a blanket replacement strategy applies. We’ve seen migration projects delayed weeks because teams discovered mid-migration that they were calling three different Bing endpoints, not one.

Microsoft’s official deprecation announcement (2025) confirmed that the Bing Search APIs v7 would be fully retired, affecting an estimated 35,000+ registered developer applications. Organizations that began migration within the first 60 days avoided the end-of-window scramble that caused production outages for hundreds of dependent applications.

Frequently Asked Questions

Q: Is Bing’s SERP API completely shut down?

A: No — Microsoft’s Bing Search API remains available, but pricing and tier restructuring in 2024–2025 made it impractical for many use cases, particularly high-volume applications and AI agents. The changes effectively ended free-tier access and significantly increased costs for commercial use, prompting most developers to evaluate alternatives.

Q: Does SearchCans support Bing as well as Google?

A: Yes. Set "t": "bing" in the payload to query Bing search results instead of Google. The response format is identical — the same code, data, title, url, description, and position fields. This makes it straightforward to run parallel queries across both engines for comprehensive coverage. Full API docs →

Q: What is the correct SearchCans API call to replace Bing SDK code?

A: SearchCans uses POST https://www.searchcans.com/api/search with a JSON body: {"s": "query", "t": "bing", "d": 10000, "p": 1} and Authorization: Bearer YOUR_KEY header. The Bing SDK’s GET-based pattern with q= and count= parameters does not apply — see the full migration code in Step 1 above.

Q: How does SearchCans handle the concurrency model differently from Bing’s API?

A: Bing’s commercial API uses requests-per-second limits. SearchCans uses Parallel Lanes — a limit on simultaneous in-flight connections, not on hourly or per-second totals. For AI agents that make bursty parallel requests (e.g., 10 concurrent searches), Parallel Lanes is architecturally superior because agents are never forced to queue behind a per-second cap. Pro plan (22 lanes) handles most production multi-agent workloads. Ready to migrate? Try SearchCans free →