API Documentation

import requests
import json
import time
import os
from datetime import datetime

# Configuration
API_KEY = "YOUR_API_KEY"
API_URL = "https://www.searchcans.com/api/search"
KEYWORDS_FILE = "keywords.txt"  # One keyword per line
OUTPUT_DIR = "serp_results"
SEARCH_ENGINE = "google"  # or "bing"
MAX_RETRIES = 3

def load_keywords(filepath):
    """Load keywords from file"""
    if not os.path.exists(filepath):
        print(f" Error: {filepath} not found")
        return []
    
    keywords = []
    with open(filepath, 'r', encoding='utf-8') as f:
        for line in f:
            keyword = line.strip()
            if keyword and not keyword.startswith('#'):
                keywords.append(keyword)
    return keywords

def search_keyword(keyword, page=1):
    """Search single keyword with SERP API"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "s": keyword,
        "t": SEARCH_ENGINE,
        "d": 20000,  # 20s server timeout
        "p": page
    }
    
    try:
        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
        result = response.json()
        
        if result.get("code") == 0:
            print(f" Success: {len(result.get('data', []))} results")
            return result
        else:
            print(f" Failed: {result.get('msg')}")
            return None
            
    except Exception as e:
        print(f" Error: {e}")
        return None

def search_with_retry(keyword):
    """Search with automatic retry"""
    for attempt in range(MAX_RETRIES):
        if attempt > 0:
            print(f"  Retry {attempt}/{MAX_RETRIES-1}...")
            time.sleep(2)
        
        result = search_keyword(keyword)
        if result:
            return result
    
    print(f"  Failed after {MAX_RETRIES} attempts")
    return None

def save_result(keyword, result, output_dir):
    """Save search result"""
    # Create safe filename
    safe_name = "".join(c if c.isalnum() or c in (' ', '-', '_') else '_' for c in keyword)
    safe_name = safe_name[:50]
    
    # Save as individual JSON
    json_file = os.path.join(output_dir, f"{safe_name}.json")
    with open(json_file, 'w', encoding='utf-8') as f:
        json.dump(result, f, ensure_ascii=False, indent=2)
    
    # Also save to summary JSONL
    jsonl_file = os.path.join(output_dir, "all_results.jsonl")
    with open(jsonl_file, 'a', encoding='utf-8') as f:
        record = {
            "keyword": keyword,
            "timestamp": datetime.now().isoformat(),
            "result": result
        }
        f.write(json.dumps(record, ensure_ascii=False) + "
")
    
    print(f"  Saved: {safe_name}.json")

def main():
    """Main execution"""
    print(" SearchCans SERP API Batch Search Tool")
    print("=" * 60)
    
    # Load keywords
    keywords = load_keywords(KEYWORDS_FILE)
    if not keywords:
        return
    
    total = len(keywords)
    print(f" Loaded {total} keywords
")
    
    # Create output directory
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    output_dir = f"{OUTPUT_DIR}_{timestamp}"
    os.makedirs(output_dir, exist_ok=True)
    print(f" Output: {output_dir}/
")
    
    # Process each keyword
    completed = 0
    for index, keyword in enumerate(keywords, 1):
        print(f"[{index}/{total}] Keyword: {keyword}")
        
        result = search_with_retry(keyword)
        
        if result:
            save_result(keyword, result, output_dir)
            
            # Extract and display URLs
            urls = [item.get("url", "") for item in result.get("data", [])]
            if urls:
                print(f"  {len(urls)} URLs found")
                for i, url in enumerate(urls[:3], 1):
                    print(f"     {i}. {url[:70]}...")
            
            completed += 1
        
        # Concurrency Control (Free tier has 1 lane, so we process serially)
        if index < total:
            time.sleep(1)
    
    # Summary
    print("
" + "=" * 60)
    print(f" Summary: {completed}/{total} successful")
    print(f" Results saved to: {output_dir}/")

if __name__ == "__main__":
    main()
              

import requests
import json
import time

def extract_content(url, retry=3):
    """
    Extract content with optimal settings and error handling
    """
    api_url = "https://www.searchcans.com/api/url"
    headers = {
        "Authorization": f"Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }
    
    payload = {
        "s": url,
        "t": "url",
        "w": 3000,    # Wait 3s for JS (use 5000ms+ for heavy sites)
        "d": 20000,   # 20s server timeout
        "b": True     # Enable browser mode
    }
    
    for attempt in range(retry):
        try:
            # Set timeout higher than 'd' parameter (30s) to avoid premature disconnection
            response = requests.post(
                api_url, 
                headers=headers, 
                json=payload, 
                timeout=35
            )
            result = response.json()
            
            if result["code"] == 0:
                # Parse the data (may be string or object)
                data = result["data"]
                if isinstance(data, str):
                    data = json.loads(data)
                
                return {
                    "title": data.get("title", ""),
                    "markdown": data.get("markdown", ""),
                    "html": data.get("html", ""),
                    "description": data.get("description", "")
                }
            else:
                print(f"API Error: {result.get('msg')}")
                if attempt < retry - 1:
                    time.sleep(2)  # Wait before retry
                    continue
                return None
                
        except requests.exceptions.Timeout:
            print(f"Timeout on attempt {attempt + 1}/{retry}")
            if attempt < retry - 1:
                time.sleep(2)
                continue
            return None
        except Exception as e:
            print(f"Error: {str(e)}")
            return None
    
    return None

# Usage Example
if __name__ == "__main__":
    url = "https://example.com/article"
    content = extract_content(url)
    
    if content:
        print(f"[SUCCESS] Title: {content['title']}")
        print(f"[INFO] Content length: {len(content['markdown'])} characters")
        
        # Save to file
        with open("output.md", "w", encoding="utf-8") as f:
            f.write(f"# {content['title']}\n\n")
            f.write(content['markdown'])
        print("[SUCCESS] Saved to output.md")
    else:
        print("[ERROR] Extraction failed")