Bing Images API Guide: Integrate Visual Search Into Your Applications

GET https://api.bitlore.in/search?search_engine=bing_images&q=machine+learning&api_key=YOUR_API_KEY

class BingImagesClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.bitlore.in/search';
  }
  
  async searchImages(query, safeSearch = 'Moderate') {
    const params = new URLSearchParams({
      search_engine: 'bing_images',
      q: query,
      safe_search: safeSearch,
      api_key: this.apiKey
    });
    
    try {
      const response = await fetch(`${this.baseUrl}?${params}`);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      return await response.json();
    } catch (error) {
      console.error('Image search failed:', error);
      throw error;
    }
  }
  
  // Helper method to get images with specific safe search level
  async getFamilyFriendlyImages(query) {
    return await this.searchImages(query, 'Strict');
  }
  
  // Method to search for high-resolution images
  filterHighResolutionImages(results) {
    return results.data.results.filter(image => {
      const [width, height] = image.size.split('×').map(Number);
      return width >= 1920 && height >= 1080; // HD resolution or better
    });
  }
}

// Usage examples for different applications
const imageClient = new BingImagesClient('YOUR_API_KEY');

// E-commerce product imagery
imageClient.searchImages('smartphone product photography')
  .then(results => {
    console.log('Product images found:', results.data.results.length);
    results.data.results.forEach(image => {
      console.log(`Title: ${image.title}`);
      console.log(`Size: ${image.size}`);
      console.log(`Thumbnail: ${image.thumbnail}`);
      console.log(`Source: ${image.link}`);
    });
  });

// Educational content with strict filtering
imageClient.getFamilyFriendlyImages('science experiments for kids')
  .then(results => {
    const safeImages = results.data.results;
    console.log('Safe educational images:', safeImages.length);
  });

// Design inspiration with high-resolution filtering
imageClient.searchImages('modern web design inspiration')
  .then(results => {
    const hdImages = imageClient.filterHighResolutionImages(results);
    console.log('High-resolution design images:', hdImages.length);
  });

import requests
import json
from typing import List, Dict, Optional
from urllib.parse import urlencode

class BingImagesAPI:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://api.bitlore.in/search'
        
    def search_images(self, query: str, safe_search: str = 'Moderate') -> Dict:
        """Search for images using Bing Images API"""
        params = {
            'search_engine': 'bing_images',
            'q': query,
            'safe_search': safe_search,
            'api_key': self.api_key
        }
        
        try:
            response = requests.get(self.base_url, params=params)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error searching images: {e}")
            return None
    
    def get_thumbnail_urls(self, query: str, limit: int = 10) -> List[str]:
        """Get thumbnail URLs for quick preview"""
        results = self.search_images(query)
        if results and results.get('data', {}).get('results'):
            thumbnails = [img['thumbnail'] for img in results['data']['results'][:limit]]
            return thumbnails
        return []
    
    def search_by_category(self, category: str, safe_search: str = 'Strict') -> Dict:
        """Search images by category with safe search"""
        category_queries = {
            'nature': 'beautiful nature landscapes photography',
            'technology': 'modern technology gadgets devices',
            'business': 'professional business meeting office',
            'education': 'classroom learning students teaching',
            'healthcare': 'medical healthcare hospital doctors'
        }
        
        query = category_queries.get(category, category)
        return self.search_images(query, safe_search)
    
    def filter_images_by_size(self, results: Dict, min_width: int = 800, min_height: int = 600) -> List[Dict]:
        """Filter images by minimum dimensions"""
        if not results or not results.get('data', {}).get('results'):
            return []
            
        filtered_images = []
        for image in results['data']['results']:
            try:
                width, height = map(int, image['size'].split('×'))
                if width >= min_width and height >= min_height:
                    filtered_images.append(image)
            except (ValueError, AttributeError):
                continue
                
        return filtered_images

# Usage examples for content management systems
api_client = BingImagesAPI('YOUR_API_KEY')

# Blog post header images
blog_images = api_client.search_images('blog header design templates', 'Moderate')
if blog_images:
    high_res_headers = api_client.filter_images_by_size(blog_images, 1920, 600)
    print(f"Found {len(high_res_headers)} suitable header images")

# Stock photography for marketing
marketing_images = api_client.search_by_category('business')
if marketing_images:
    thumbnails = api_client.get_thumbnail_urls('business team collaboration', 20)
    print(f"Retrieved {len(thumbnails)} business image thumbnails")

# Educational content with strict filtering
education_results = api_client.search_by_category('education', 'Strict')
safe_educational_images = api_client.filter_images_by_size(education_results, 1024, 768)
print(f"Safe educational images: {len(safe_educational_images)}")

# E-commerce product imagery
product_images = api_client.search_images('product photography white background')
if product_images:
    for idx, image in enumerate(product_images['data']['results'][:5]):
        print(f"Product Image {idx+1}: {image['title']} ({image['size']})")
        print(f"Source: {image['link']}")
        print(f"Thumbnail: {image['thumbnail']}\n")