Results

A search returns a SearchResults (Rust) / SearchResponse (SDK) containing ranked, deduplicated results and per-engine metadata.

Iterating Results

let results = search.search(query).await?;

println!("{} results in {}ms", results.count, results.duration_ms);

for result in results.items().iter().take(10) {
    println!("{}: {}", result.title, result.url);
    println!("  Score: {:.2}", result.score);
    println!("  Engines: {:?}", result.engines);
    if let Some(date) = &result.published_date {
        println!("  Published: {}", date);
    }
}

response = await search.search("rust programming")

print(f"{response.count} results in {response.duration_ms}ms")

for r in response.results:
    print(f"{r.title}: {r.url}")
    print(f"  Score: {r.score:.2f}")
    print(f"  Engines: {r.engines}")
    if r.published_date:
        print(f"  Published: {r.published_date}")

const response = await search.search('rust programming');

console.log(`${response.count} results in ${response.durationMs}ms`);

for (const r of response.results) {
  console.log(`${r.title}: ${r.url}`);
  console.log(`  Score: ${r.score.toFixed(2)}`);
  console.log(`  Engines: ${r.engines.join(', ')}`);
  if (r.publishedDate) {
    console.log(`  Published: ${r.publishedDate}`);
  }
}

SearchResult Fields

Prop

Type

Python uses snake_case (result_type, published_date). Node.js uses camelCase (resultType, publishedDate).

Result Types

pub enum ResultType {
    Default,   // Standard web result
    Answer,    // Direct answer (e.g., Wikipedia infobox)
    News,      // News article
    Image,     // Image result
    Video,     // Video result
}

Deduplication

Results from multiple engines are merged by normalized URL. When two engines return the same page:

The best title and snippet are kept
Both engine names are added to engines
Positions from both engines are recorded
Score is calculated from all contributing engines

// Result found by 3 engines ranks significantly higher than one found by 1
for result in results.items().iter().take(5) {
    let coverage = result.engines.len();
    println!("[{coverage} engines] {:.2} — {}", result.score, result.title);
}

Engine Errors

Each engine runs independently — failures don't block other engines:

for (engine, error) in results.errors() {
    eprintln!("Engine '{}' failed: {}", engine, error);
}

for err in response.errors:
    print(f"Engine '{err.engine}' failed: {err.message}")

for (const err of response.errors) {
  console.error(`Engine '${err.engine}' failed: ${err.message}`);
}

Suggestions and Answers (Rust)

for suggestion in results.suggestions() {
    println!("Did you mean: {}", suggestion);
}

for answer in results.answers() {
    println!("Answer: {}", answer);
}

SearchResults / SearchResponse API

Rust (`SearchResults`)

Prop

Type

Python (`SearchResponse`)

Prop

Type

Node.js (`SearchResponse`)

Prop

Type

Error Handling

match search.search(query).await {
    Ok(results) => {
        // Per-engine failures don't block — check errors()
        for (engine, error) in results.errors() {
            eprintln!("Engine '{}' failed: {}", engine, error);
        }
    }
    Err(e) => eprintln!("Search failed: {}", e),
}

try:
    response = await search.search('query')
except SearchError as e:
    print(f'Search failed: {e}')

# Per-engine failures don't raise — check response.errors
for err in response.errors:
    print(f"Engine '{err.engine}' failed: {err.message}")

Prop

Type

try {
  const response = await search.search('query');
} catch (err) {
  if (err instanceof SearchError) {
    console.error(`Search failed: ${err.message}`);
  }
}

// Per-engine failures don't throw — check response.errors
for (const err of response.errors) {
  console.warn(`Engine '${err.engine}' failed: ${err.message}`);
}

Prop

Type

Results

On this page