Search

Einführung

Die AnyCrawl-Search-API liefert programmgesteuert Suchergebnisse mehrerer Suchmaschinen. Für LLMs aufbereitet: saubere, strukturierte Daten.

Die API antwortet sofort und synchron – kein Polling, keine Webhooks. Mehrere Engines und mehrere Ergebnisseiten pro Anfrage sind möglich.

Kernfunktionen

Mehrere Engines: derzeit Google, weitere geplant
LLM-optimiert: strukturierte JSON-Daten
Mehrsprachig: Sprachen und Regionen wählbar
Mehrseitige Ergebnisse: mehrere SERP-Seiten in einer Anfrage
Performance: Hohe Parallelität mit asynchroner Verarbeitung
Sofortantwort: Synchrones API
Umfassend: Suchtreffer und Suchvorschläge

API-Endpunkt

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

Nutzungsbeispiele

Basis-Suche (Standard: Google)

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

Mehrseitige Suche

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
  }'

Suche mit Sprache/Region

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

Paginierung

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
  }'

Safe Search

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

Anfrageparameter

Parameter	Typ	Erforderlich	Standard	Beschreibung
`query`	string	Ja	-	Suchanfrage
`template_id`	string	Nein	-	Template-ID für diese Suche
`variables`	object	Nein	-	Template-Variablen (nur mit `template_id`)
`engine`	enum	Nein	`google`	Suchmaschine. Derzeit: `google`
`limit`	number	Nein	10	Max. Treffer pro Seite
`offset`	number	Nein	0	Überspringen (Paginierung)
`pages`	number	Nein	1	Anzahl SERP-Seiten (min: 1, max: 20)
`lang`	string	Nein	`en`	Sprach-Locale (z. B. `en`, `zh`, `de`)
`country`	string	Nein	-	Länder-Locale (z. B. `US`, `DE`)
`timeRange`	enum	Nein	-	Zeitraum: `day`, `week`, `month`, `year`
`sources`	enum	Nein	-	Quellen: `web`, `images`, `news` (SearXNG)
`safe_search`	number \| null	Nein	null	Google SafeSearch: `0` aus, `1` mittel, `2` streng, `null` Standard. Nur Google.

Optional: `scrape_options` für Ergebnis-URLs

Wenn gesetzt, kann jede Ergebnis-URL mit diesen Optionen gescrapet werden (wie /v1/scrape ohne Top-Level url). Nur-Browser-Optionen werden bei Nicht-Browser-Scraping ignoriert.

Feld	Typ	Standard	Hinweise
`engine`	enum	-	Engine: `auto`, `cheerio`, `playwright`, `puppeteer`
`formats`	array of enum	`["markdown"]`	Ausgabeformate: `markdown`, `html`, `text`, `screenshot`, `screenshot@fullPage`, `rawHtml`, `json`, `summary`, `links`
`timeout`	number	`60000`	Timeout (ms)
`wait_for`	number	-	Verzögerung (ms); nur Browser; unter `wait_for_selector`
`wait_until`	enum	-	`load`, `domcontentloaded`, `networkidle`, `commit`
`wait_for_selector`	string, object, or array	-	Selektor(en) warten (Browser); Vorrang vor `wait_for`
`include_tags`	array of string	-	CSS-Selektoren einschließen
`exclude_tags`	array of string	-	CSS-Selektoren ausschließen
`only_main_content`	boolean	`true`	Nur Hauptinhalt (`include_tags` Vorrang)
`proxy`	string (URI)	-	Optionaler Proxy
`json_options`	object	-	JSON-Extraktion (schema, user_prompt, …)
`extract_source`	enum	`markdown`	JSON-Quelle: `markdown` oder `html`
`ocr_options`	boolean	`false`	OCR nur Markdown-Bilder
`max_age`	number	-	Cache (ms); `0` = kein Lesen
`store_in_cache`	boolean	`true`	Page Cache pro Ergebnis-Scrape

Unterstützte Suchmaschinen

`google` (Standard)

Einsatz: Allgemeine Websuche
Vorteile: breite Treffer, viele Sprachen/Regionen
Funktionen: Treffer + Vorschläge; SafeSearch (aus/mittel/streng)
Empfehlung: Recherche, Content-Discovery
SafeSearch: safe_search 0, 1, 2 oder null

Antwortformat

Erfolg (HTTP 200)

Suche erfolgreich

{
    "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"
        }
    ]
}

Ergebnistypen

Suchergebnisse: Titel, URL, Beschreibung, Quelle
Vorschläge: verwandte Suchanfragen ohne URL

Fehlerantworten

400 – Validierung

{
    "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'"]
    }
}

401 – Authentifizierung

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

402 – Zahlung erforderlich

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

Best Practices

Suchmaschine

Allgemein → google (derzeit einzige Option)
Mehrsprachig → passendes lang
Mehr Treffer → pages erhöhen

Performance

pages: mehrere SERP-Seiten in einer Anfrage statt vieler Einzelaufrufe
Sprache: lang auf Zielregion abstimmen
Anfrage: präzise Keywords

Fehlerbehandlung

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);
}

Hohe Parallelität

Die API unterstützt hohe Parallelität. Viele gleichzeitige Suchanfragen sind unkritisch:

// 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`);