JavaScript/Node.js SDK

// Scrape webpage content
async function scrapeWebpage() {
  try {
    const result = await client.scrape({
      url: 'https://example.com/article',
      extractOptions: ['title', 'text', 'links', 'images'],
      followRedirects: true,
      waitForSelector: '.content', // optional
      removeSelectors: ['.ads', '.popup'] // optional
    });
    
    console.log('Page title:', result.primaryContent.title);
    console.log('Content length:', result.primaryContent.text.length);
    console.log('Found links:', result.extractedData.links.length);
    console.log('Found images:', result.extractedData.images.length);
    
  } catch (error) {
    console.error('Scraping failed:', error.message);
  }
}

// Bulk scraping
async function bulkScrape() {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2', 
    'https://example.com/page3'
  ];
  
  try {
    const results = await client.scrapeBulk({
      urls: urls,
      extractOptions: ['title', 'text'],
      concurrent: 2 // Process 2 URLs at once
    });
    
    results.forEach((result, index) => {
      if (result.success) {
        console.log(`${urls[index]}: ${result.data.primaryContent.title}`);
      } else {
        console.error(`${urls[index]} failed: ${result.error}`);
      }
    });
    
  } catch (error) {
    console.error('Bulk scraping failed:', error.message);
  }
}

// AI-powered research
async function researchTopic() {
  try {
    const result = await client.research({
      topic: 'sustainable energy solutions 2025',
      maxSources: 10,
      includeImages: true,
      language: 'en'
    });
    
    console.log('Research summary:');
    console.log(result.summary);
    
    console.log('\nKey insights:');
    result.keyInsights.forEach((insight, index) => {
      console.log(`${index + 1}. ${insight}`);
    });
    
    console.log('\nSources analyzed:');
    result.sources.forEach((source, index) => {
      console.log(`${index + 1}. ${source.title}`);
      console.log(`   URL: ${source.url}`);
      console.log(`   Credibility: ${source.credibilityScore}`);
    });
    
  } catch (error) {
    console.error('Research failed:', error.message);
  }
}

import { SearchHive } from 'searchhive-js';

// Advanced configuration
const client = new SearchHive({
  apiKey: process.env.SEARCHHIVE_API_KEY,
  
  // Network settings
  timeout: 60000, // 60 second timeout
  retries: 5,     // Retry up to 5 times
  retryDelay: 1000, // Start with 1 second delay
  
  // Rate limiting
  rateLimit: {
    requestsPerMinute: 100,
    burstLimit: 10
  },
  
  // Custom headers
  headers: {
    'User-Agent': 'MyApp/1.0.0',
    'X-Custom-Header': 'value'
  },
  
  // Proxy support
  proxy: {
    host: 'proxy.example.com',
    port: 8080,
    auth: {
      username: 'user',
      password: 'pass'
    }
  },
  
  // Response customization
  responseFormat: 'detailed', // 'simple' or 'detailed'
  
  // Error handling
  throwOnError: true, // Default: true
  
  // Logging
  debug: process.env.NODE_ENV === 'development'
});

// Override settings per request
const result = await client.search({
  query: 'test query',
  maxResults: 5
}, {
  timeout: 10000, // Override timeout for this request
  retries: 1      // Override retries for this request
});

import { 
  SearchHiveError, 
  RateLimitError, 
  AuthenticationError,
  InsufficientCreditsError 
} from 'searchhive-js';

async function robustApiCall() {
  try {
    const result = await client.search({
      query: 'example query',
      maxResults: 10
    });
    
    return result;
    
  } catch (error) {
    if (error instanceof RateLimitError) {
      console.log(`Rate limited. Retry after ${error.retryAfter} seconds`);
      
      // Wait and retry
      await new Promise(resolve => 
        setTimeout(resolve, error.retryAfter * 1000)
      );
      return robustApiCall(); // Recursive retry
      
    } else if (error instanceof AuthenticationError) {
      console.error('Authentication failed. Check your API key.');
      throw error;
      
    } else if (error instanceof InsufficientCreditsError) {
      console.error('No credits remaining. Upgrade your plan.');
      throw error;
      
    } else if (error instanceof SearchHiveError) {
      console.error(`API error (${error.statusCode}): ${error.message}`);
      
      // Log additional context
      console.error('Request ID:', error.requestId);
      console.error('Response:', error.response);
      
      throw error;
      
    } else {
      console.error('Unexpected error:', error);
      throw error;
    }
  }
}

// TypeScript support with full type definitions
import { 
  SearchHive, 
  SearchResponse, 
  ScrapeResponse,
  ResearchResponse,
  SearchOptions,
  ScrapeOptions,
  ResearchOptions
} from 'searchhive-js';

const client = new SearchHive({
  apiKey: process.env.SEARCHHIVE_API_KEY!
});

// Typed search function
async function typedSearch(options: SearchOptions): Promise<SearchResponse> {
  return await client.search(options);
}

// Interface for custom result processing
interface ProcessedResult {
  title: string;
  url: string;
  summary: string;
  relevanceScore: number;
}

async function processSearchResults(query: string): Promise<ProcessedResult[]> {
  const response: SearchResponse = await client.search({
    query,
    maxResults: 20
  });
  
  return response.searchResults.map((result): ProcessedResult => ({
    title: result.title,
    url: result.link,
    summary: result.snippet,
    relevanceScore: result.relevanceScore ?? 0
  }));
}

// Generic function with constraints
async function performOperation<T extends SearchOptions | ScrapeOptions>(
  operation: 'search' | 'scrape',
  options: T
): Promise<T extends SearchOptions ? SearchResponse : ScrapeResponse> {
  if (operation === 'search') {
    return client.search(options as SearchOptions) as any;
  } else {
    return client.scrape(options as ScrapeOptions) as any;
  }
}