Search

POST https://api.anycrawl.dev/v1/search

{
    "success": true,
    "data": [
        {
            "title": "AlsoAsked: People Also Ask keyword research tool",
            "url": "https://alsoasked.com/",
            "description": "Find the questions people also ask. Enter a question, brand or search query. e.g. 'keyword research'.",
            "source": "Google Search Result"
        },
        {
            "title": "OpenAI ChatGPT Features and Benefits",
            "url": "https://openai.com/chatgpt",
            "description": "ChatGPT is an AI assistant that can help with writing, research, and problem-solving.",
            "source": "Google Search Result"
        },
        {
            "title": "Keyword tool",
            "source": "Google Suggestions"
        }
    ]
}

{
    "success": false,
    "error": "Validation error",
    "details": {
        "issues": [
            {
                "field": "engine",
                "message": "Invalid enum value. Expected 'google', received 'invalid'",
                "code": "invalid_enum_value"
            }
        ],
        "messages": ["Invalid enum value. Expected 'google', received 'invalid'"]
    }
}

{
    "success": false,
    "error": "Invalid API key"
}

{
    "success": false,
    "error": "Insufficient credits. Please upgrade your plan or purchase more credits."
}

curl -X POST "https://api.anycrawl.dev/v1/search" \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "OpenAI ChatGPT"
  }'

curl -X POST "https://api.anycrawl.dev/v1/search" \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "machine learning tutorials",
    "pages": 3,
    "limit": 10
  }'

curl -X POST "https://api.anycrawl.dev/v1/search" \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "人工智能",
    "lang": "zh",
    "pages": 2
  }'

curl -X POST "https://api.anycrawl.dev/v1/search" \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "web scraping tools",
    "offset": 20,
    "limit": 10
  }'

curl -X POST "https://api.anycrawl.dev/v1/search" \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "educational content",
    "safeSearch": 0
  }'

const response = await fetch("https://api.anycrawl.dev/v1/search", {
    method: "POST",
    headers: {
        Authorization: "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        query: "artificial intelligence trends",
        engine: "google",
    }),
});

const result = await response.json();
console.log(result.data); // Array of search results

interface SearchOptions {
    query: string;
    engine?: "google";
    pages?: number;
    limit?: number;
    lang?: string;
    safeSearch?: number | null; // 0: off, 1: medium, 2: high, null: default (Google only)
}

async function searchWithPagination(options: SearchOptions) {
    const response = await fetch("https://api.anycrawl.dev/v1/search", {
        method: "POST",
        headers: {
            Authorization: "Bearer YOUR_API_KEY",
            "Content-Type": "application/json",
        },
        body: JSON.stringify({
            query: options.query,
            engine: options.engine || "google",
            pages: options.pages || 1,
            limit: options.limit || 10,
            lang: options.lang || "en",
            safeSearch: options.safeSearch,
        }),
    });

    const result = await response.json();

    if (result.success) {
        return result.data.filter((item) => item.url); // Filter only results with URLs
    } else {
        throw new Error(result.error);
    }
}

// Usage
const searchResults = await searchWithPagination({
    query: "best web scraping APIs",
    pages: 3,
    limit: 10,
    lang: "en",
});

import requests

response = requests.post(
    'https://api.anycrawl.dev/v1/search',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'query': 'data science tools',
        'engine': 'google'
    }
)

result = response.json()
if result['success']:
    for item in result['data']:
        if 'url' in item:  # Search result
            print(f"Title: {item['title']}")
            print(f"URL: {item['url']}")
            print(f"Description: {item['description']}")
            print("---")
        else:  # Search suggestion
            print(f"Suggestion: {item['title']}")
else:
    print(f"Search failed: {result.get('error', 'Unknown error')}")

import requests
from typing import List, Dict, Any

def search_web(query: str, pages: int = 1, lang: str = "en") -> List[Dict[str, Any]]:
    """
    Search the web using AnyCrawl Search API

    Args:
        query: Search query string
        pages: Number of pages to retrieve
        lang: Language locale

    Returns:
        List of search results

    Raises:
        Exception: If search fails
    """
    try:
        response = requests.post(
            'https://api.anycrawl.dev/v1/search',
            headers={
                'Authorization': 'Bearer YOUR_API_KEY',
                'Content-Type': 'application/json'
            },
            json={
                'query': query,
                'pages': pages,
                'lang': lang,
                'limit': 10
            },
            timeout=30
        )

        response.raise_for_status()
        result = response.json()

        if result['success']:
            return result['data']
        else:
            raise Exception(f"Search failed: {result.get('error', 'Unknown error')}")

    except requests.RequestException as e:
        raise Exception(f"Request failed: {str(e)}")

# Usage
try:
    results = search_web("machine learning frameworks", pages=2, lang="en")
    print(f"Found {len(results)} results")

    # Separate search results from suggestions
    search_results = [r for r in results if 'url' in r]
    suggestions = [r for r in results if 'url' not in r]

    print(f"Search Results: {len(search_results)}")
    print(f"Suggestions: {len(suggestions)}")

except Exception as e:
    print(f"Error: {e}")

try {
    const response = await fetch("/v1/search", {
        method: "POST",
        headers: {
            Authorization: "Bearer YOUR_API_KEY",
            "Content-Type": "application/json",
        },
        body: JSON.stringify({
            query: "artificial intelligence",
            pages: 2,
        }),
    });

    const result = await response.json();

    if (result.success) {
        // Handle successful result
        console.log("Found results:", result.data.length);

        // Separate search results from suggestions
        const searchResults = result.data.filter((item) => item.url);
        const suggestions = result.data.filter((item) => !item.url);

        console.log("Search Results:", searchResults.length);
        console.log("Suggestions:", suggestions.length);
    } else {
        // Handle search failure
        console.error("Search failed:", result.error);
    }
} catch (error) {
    // Handle network error
    console.error("Request failed:", error);
}

// Concurrent searching example
const queries = ["machine learning", "artificial intelligence", "data science"];

const searchPromises = queries.map((query) =>
    fetch("/v1/search", {
        method: "POST",
        headers: {
            Authorization: "Bearer YOUR_API_KEY",
            "Content-Type": "application/json",
        },
        body: JSON.stringify({ query, engine: "google", pages: 2 }),
    }).then((res) => res.json())
);

// All requests execute concurrently and return immediately
const results = await Promise.all(searchPromises);
console.log(`Completed ${results.length} searches simultaneously`);