Building AI Agents with Google & Bing SERP API

One of SERPpost’s unique features is dual search engine support. In this tutorial, you’ll learn how to build an AI agent that can seamlessly switch between Google and Bing search results.

Why Use Both Google and Bing?

• Data diversity: Different algorithms, different results
• Market coverage: Bing dominates in enterprise (Windows ecosystem)
• Cost efficiency: One API, two search engines
• Redundancy: Fallback option if one engine has issues

Quick Start

Installation

npm install axios

Basic Usage

import axios from 'axios';

const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://serppost.com/api';

// Google Search
async function searchGoogle(query) {
  const response = await axios.get(`${BASE_URL}/search`, {
    params: {
      s: query,
      t: 'google',  // �?Google engine
      p: 1
    },
    headers: {
      'Authorization': `Bearer ${API_KEY}`
    }
  });
  return response.data;
}

// Bing Search
async function searchBing(query) {
  const response = await axios.get(`${BASE_URL}/search`, {
    params: {
      s: query,
      t: 'bing',    // �?Bing engine (just change this!)
      p: 1
    },
    headers: {
      'Authorization': `Bearer ${API_KEY}`
    }
  });
  return response.data;
}

Building a Smart AI Agent

Here’s a complete example of an AI agent that uses both search engines:

import requests
from typing import List, Dict

class SmartSearchAgent:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://serppost.com/api"
    
    def search(self, query: str, engine: str = "google") -> Dict:
        """Search using specified engine (google or bing)"""
        headers = {"Authorization": f"Bearer {self.api_key}"}
        params = {
            "s": query,
            "t": engine,
            "p": 1
        }
        
        response = requests.get(
            f"{self.base_url}/search",
            headers=headers,
            params=params
        )
        return response.json()
    
    def compare_results(self, query: str) -> Dict:
        """Compare Google and Bing results side-by-side"""
        google_results = self.search(query, "google")
        bing_results = self.search(query, "bing")
        
        return {
            "query": query,
            "google": google_results,
            "bing": bing_results,
            "comparison": self.analyze_differences(
                google_results, 
                bing_results
            )
        }
    
    def analyze_differences(self, google: Dict, bing: Dict) -> Dict:
        """Analyze differences between search engines"""
        # Your analysis logic here
        return {
            "unique_to_google": [],
            "unique_to_bing": [],
            "common": []
        }

# Usage
agent = SmartSearchAgent("your_api_key")

# Single search
results = agent.search("AI agents", engine="google")

# Compare both engines
comparison = agent.compare_results("web scraping best practices")

Advanced: Automatic Fallback

async function searchWithFallback(query) {
  try {
    // Try Google first
    return await searchGoogle(query);
  } catch (error) {
    console.log('Google failed, trying Bing...');
    // Fallback to Bing
    return await searchBing(query);
  }
}

Best Practices

1. Cache results: Avoid redundant API calls
2. Use both engines: Get comprehensive data
3. Handle errors: Implement fallback logic
4. Rate limiting: Respect API limits

Conclusion

With SERPpost’s dual engine support, you can build more robust AI agents with:

• �?Greater data diversity
• �?Better fault tolerance
• �?Cost efficiency (one API for both)
• �?Simple implementation (just change one parameter)

Get started with 100 free credits →

Related Articles

• Google vs Bing SERP API Comparison
• SERP API Best Practices 2025
• Multi Search Engine API