### Install Dependencies

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Install the required Python packages using pip.

```bash
pip install -r requirements.txt
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Installs the necessary Python packages for the project. Optionally, install the package itself for development.

```bash
pip install -r requirements.txt
python setup.py install   # optional, to install the package itself
```

--------------------------------

### CLI Usage Examples

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Command-line interface for the search engine library, supporting various engines, output formats, deduplication, filtering, proxies, and pagination.

```bash
# Single engine, JSON output
python search_engines_cli.py -e bing -q "neural networks" -p 3 -o json -n /tmp/nn_results
```

```bash
# Multiple engines, print + CSV, deduplicate, filter to title matches only
python search_engines_cli.py -e bing,yahoo,startpage -q "quantum computing" -p 2 -o print,csv -i -f title -n /tmp/quantum
```

```bash
# All engines via Tor SOCKS5 proxy, 1 page
python search_engines_cli.py -e all -q "privacy tools" -p 1 -proxy socks5://127.0.0.1:9050 -o html -n /tmp/privacy
```

```bash
# Brave with API key set in environment
BRAVE_API_KEY=your_key_here python search_engines_cli.py -e brave -q "rust async" -p 2 -o print
```

```text
# Expected console output:
# Searching Bing
# page: 1        links: 10
# page: 2        links: 20
# page: 3        links: 28
# 1  https://en.wikipedia.org/wiki/Neural_network   Neural network - Wikipedia
# 2  https://www.ibm.com/topics/neural-networks     What are Neural Networks? | IBM
# ...
```

--------------------------------

### CLI Search Command

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Example of using the command-line interface to search across specified engines (bing, yahoo) for a query, with JSON and print output.

```bash
python search_engines_cli.py -e bing,yahoo -q "my query" -o json,print
```

--------------------------------

### Adding a Custom Engine

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Instructions on how to extend the `SearchEngine` class to create and register a custom search engine.

```APIDOC
## Adding a custom engine

Extend `SearchEngine`, implement `_selectors`, `_first_page`, and `_next_page`, then register the class in `search_engines_dict`.

```python
# search_engines/engines/myengine.py
from ..engine import SearchEngine
from ..config import PROXY, TIMEOUT

class MyEngine(SearchEngine):
    def __init__(self, proxy=PROXY, timeout=TIMEOUT, *args, **kwargs):
        super().__init__(proxy, timeout, *args, **kwargs)
        self._base_url = "https://www.myengine.com"

    def _selectors(self, element):
        return {
            "url":   "h3 a[href]",
            "title": "h3",
            "text":  "p.description",
            "links": "div.result",
            "next":  "a.next-page",
        }[element]

    async def _first_page(self):
        return {"url": f"{self._base_url}/search?q={self._query}", "data": None}

    def _next_page(self, tags):
        selector = self._selectors("next")
        href = self._get_tag_item(tags.select_one(selector), "href")
        url = (self._base_url + href) if href else None
        return {"url": url, "data": None}


# search_engines/engines/__init__.py  — add one line:
from .myengine import MyEngine
search_engines_dict["myengine"] = MyEngine

# Usage:
import asyncio
from search_engines.engines.myengine import MyEngine

async def main():
    async with MyEngine() as e:
        results = await e.search("hello world", pages=1)
        print(results.links())

asyncio.run(main())
```
```

--------------------------------

### Add a Custom Search Engine

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Extends the `SearchEngine` class to implement custom scraping logic for a new search engine. Requires implementing `_selectors`, `_first_page`, and `_next_page`, and registering the class.

```python
# search_engines/engines/myengine.py
from ..engine import SearchEngine
from ..config import PROXY, TIMEOUT

class MyEngine(SearchEngine):
    def __init__(self, proxy=PROXY, timeout=TIMEOUT, *args, **kwargs):
        super().__init__(proxy, timeout, *args, **kwargs)
        self._base_url = "https://www.myengine.com"

    def _selectors(self, element):
        return {
            "url":   "h3 a[href]",
            "title": "h3",
            "text":  "p.description",
            "links": "div.result",
            "next":  "a.next-page",
        }[element]

    async def _first_page(self):
        return {"url": f"{self._base_url}/search?q={self._query}", "data": None}

    def _next_page(self, tags):
        selector = self._selectors("next")
        href = self._get_tag_item(tags.select_one(selector), "href")
        url = (self._base_url + href) if href else None
        return {"url": url, "data": None}


# search_engines/engines/__init__.py  — add one line:
from .myengine import MyEngine
search_engines_dict["myengine"] = MyEngine

# Usage:
import asyncio
from search_engines.engines.myengine import MyEngine

async def main():
    async with MyEngine() as e:
        results = await e.search("hello world", pages=1)
        print(results.links())

asyncio.run(main())
```

--------------------------------

### SearchEngine.output() - Export Results

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Serializes the current engine's results to one or more specified formats (print, html, csv, json) and saves them to a file. The path is the destination filename without the extension.

```APIDOC
## `SearchEngine.output(output, path)` — Export results to file

Serializes the current engine's results to one or more formats. `output` is a string containing any combination of `print`, `html`, `csv`, `json`. `path` is the destination filename without extension; defaults to `search_engines/search_results/<query>`.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        await engine.search("data science tools", pages=3)

    # Write all four formats simultaneously
    engine.output("print,html,csv,json", path="/tmp/ds_tools")
    # Creates:
    #   /tmp/ds_tools.html
    #   /tmp/ds_tools.csv
    #   /tmp/ds_tools.json
    # Also prints numbered results to stdout

asyncio.run(main())
```
```

--------------------------------

### CLI - search_engines_cli.py

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Command-line interface for the Async Search Scraper library, supporting various engines, output formats, deduplication, field filtering, proxy, and pagination.

```APIDOC
## CLI — `search_engines_cli.py`

Command-line interface wrapping the full library. Supports all engines, multi-engine fan-out, output formats, deduplication, field filtering, proxy, and pagination.

```bash
# Single engine, JSON output
python search_engines_cli.py -e bing -q "neural networks" -p 3 -o json -n /tmp/nn_results

# Multiple engines, print + CSV, deduplicate, filter to title matches only
python search_engines_cli.py -e bing,yahoo,startpage -q "quantum computing" -p 2 -o print,csv -i -f title -n /tmp/quantum

# All engines via Tor SOCKS5 proxy, 1 page
python search_engines_cli.py -e all -q "privacy tools" -p 1 -proxy socks5://127.0.0.1:9050 -o html -n /tmp/privacy

# Brave with API key set in environment
BRAVE_API_KEY=your_key_here python search_engines_cli.py -e brave -q "rust async" -p 2 -o print

# Expected console output:
# Searching Bing
# page: 1        links: 10
# page: 2        links: 20
# page: 3        links: 28
# 1  https://en.wikipedia.org/wiki/Neural_network   Neural network - Wikipedia
# 2  https://www.ibm.com/topics/neural-networks     What are Neural Networks? | IBM
# ...
```
```

--------------------------------

### Basic Search with Bing

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Perform a basic asynchronous search using the Bing engine and print the resulting links.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        results = await engine.search("my query")
        print(results.links())

asyncio.run(main())
```

--------------------------------

### SearchEngine.search(query, pages)

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Queries a single search engine for a given query, fetching results up to a specified number of pages. It handles pagination, parsing, and filtering, returning a SearchResults object.

```APIDOC
## `SearchEngine.search(query, pages)` — Query a single engine

Core async method that drives the pagination loop for any individual engine. It sends requests page-by-page up to `pages` (default `20`), parses HTML with BeautifulSoup, applies configured filters, and collects results into `self.results`. Returns a `SearchResults` object.

```python
import asyncio
from search_engines import Bing

async def main():
    # proxy and timeout are optional constructor kwargs
    async with Bing(timeout=15) as engine:
        # search up to 3 pages, collect all results
        results = await engine.search("python async programming", pages=3)

        # Iterate over result dicts
        for item in results:
            print(f"[{item['host']}] {item['title']}")
            print(f"  URL : {item['link']}")
            print(f"  Desc: {item['text'][:80]}")

        print(f"\nTotal results: {len(results)}")
        # Expected output:
        # [python.org] Welcome to Python.org
        #   URL : https://www.python.org/
        #   Desc: The official home of the Python Programming Language.
        # ...
        # Total results: 27

asyncio.run(main())
```
```

--------------------------------

### Brave Search with API Key

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Perform an asynchronous search using the Brave engine, authenticating with an API key provided via environment variable or constructor argument.

```python
import asyncio, os
from search_engines import Brave

async def main():
    async with Brave(api_key=os.environ["BRAVE_API_KEY"]) as engine:
        results = await engine.search("my query")
        print(results.links())

asyncio.run(main())
```

--------------------------------

### Query a Single Engine with Pagination

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Use the `search` method to query a single search engine and retrieve results across multiple pages. The `pages` argument controls the maximum number of pages to fetch. Results are returned as a `SearchResults` object.

```python
import asyncio
from search_engines import Bing

async def main():
    # proxy and timeout are optional constructor kwargs
    async with Bing(timeout=15) as engine:
        # search up to 3 pages, collect all results
        results = await engine.search("python async programming", pages=3)

        # Iterate over result dicts
        for item in results:
            print(f"[{item['host']}] {item['title']}")
            print(f"  URL : {item['link']}")
            print(f"  Desc: {item['text'][:80]}")

        print(f"\nTotal results: {len(results)}")
        # Expected output:
        # [python.org] Welcome to Python.org
        #   URL : https://www.python.org/
        #   Desc: The official home of the Python Programming Language.
        # ...
        # Total results: 27

asyncio.run(main())
```

--------------------------------

### Export Search Results to File

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Serializes search results to specified formats (print, html, csv, json) and saves them to a file. The path is the destination filename without extension.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        await engine.search("data science tools", pages=3)

    # Write all four formats simultaneously
    engine.output("print,html,csv,json", path="/tmp/ds_tools")
    # Creates:
    #   /tmp/ds_tools.html
    #   /tmp/ds_tools.csv
    #   /tmp/ds_tools.json
    # Also prints numbered results to stdout

asyncio.run(main())
```

--------------------------------

### Query Brave Search API

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Use the Brave engine to query the Brave Search REST API. The API key can be provided during initialization or via the BRAVE_API_KEY environment variable. Supports pagination up to 10 pages.

```python
import asyncio
import os
from search_engines import Brave

async def main():
    # Key via constructor or env var BRAVE_API_KEY
    async with Brave(api_key=os.environ["BRAVE_API_KEY"]) as engine:
        engine.ignore_duplicate_urls = True
        results = await engine.search("rust programming language", pages=2)

        print(f"Got {len(results)} results")
        for r in results:
            print(r["link"], "|", r["title"])
        # Expected:
        # https://www.rust-lang.org/ | Rust Programming Language
        # https://doc.rust-lang.org/ | The Rust Programming Language - doc.rust-lang.org
        # ...

asyncio.run(main())
```

--------------------------------

### SearchEngine.ignore_duplicate_urls / ignore_duplicate_domains

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Boolean flags to control result deduplication. `ignore_duplicate_urls` removes results with identical URLs, while `ignore_duplicate_domains` ensures only one result per domain is kept.

```APIDOC
## `SearchEngine.ignore_duplicate_urls` / `ignore_duplicate_domains` — Deduplication flags

Boolean instance attributes on every engine (and `MultipleSearchEngines`). Setting `ignore_duplicate_urls = True` drops any result whose URL has already been collected; `ignore_duplicate_domains = True` drops results from already-seen domains. Both default to `False`.

```python
import asyncio
from search_engines import Yahoo

async def main():
    async with Yahoo() as engine:
        engine.ignore_duplicate_urls = True
        engine.ignore_duplicate_domains = True  # one result per domain only
        results = await engine.search("machine learning", pages=5)
        print(f"Unique domains: {len(results)}")
        print(results.hosts())
        # Expected: ['arxiv.org', 'wikipedia.org', 'coursera.org', ...]

asyncio.run(main())
```
```

--------------------------------

### Configure Deduplication of Results

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Control result deduplication using `ignore_duplicate_urls` and `ignore_duplicate_domains` flags. Set these to `True` to automatically remove duplicate URLs or results from the same domain, respectively. Defaults are `False`.

```python
import asyncio
from search_engines import Yahoo

async def main():
    async with Yahoo() as engine:
        engine.ignore_duplicate_urls = True
        engine.ignore_duplicate_domains = True  # one result per domain only
        results = await engine.search("machine learning", pages=5)
        print(f"Unique domains: {len(results)}")
        print(results.hosts())
        # Expected: ['arxiv.org', 'wikipedia.org', 'coursera.org', ...]

asyncio.run(main())
```

--------------------------------

### SearchEngine.set_headers(headers)

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Allows overriding the default HTTP headers sent with requests. This is useful for setting custom User-Agents, authentication tokens, or other required headers for specific search engines.

```APIDOC
## `SearchEngine.set_headers(headers)` — Override HTTP headers

Merges custom HTTP headers into the underlying `aiohttp` session's header dict. Useful for setting custom `User-Agent`, `Accept-Language`, authorization tokens, or any other header the target engine requires.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        engine.set_headers({
            "Accept-Language": "fr-FR,fr;q=0.9",
            "Accept": "text/html,application/xhtml+xml",
        })
        results = await engine.search("intelligence artificielle", pages=1)
        for r in results:
            print(r["title"])

asyncio.run(main())
```
```

--------------------------------

### Multiple Engines with Deduplication

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Search across multiple engines (Bing, Yahoo, Startpage) asynchronously and collect unique URLs. Set `ignore_duplicate_urls` to True for deduplication.

```python
import asyncio
from search_engines import Bing, Yahoo, Startpage

async def main():
    all_links = set()
    for cls in (Bing, Yahoo, Startpage):
        async with cls() as engine:
            engine.ignore_duplicate_urls = True
            results = await engine.search("python programming", pages=1)
            all_links.update(results.links())
    print(f"{len(all_links)} unique URLs")

asyncio.run(main())
```

--------------------------------

### Accessing Search Results Data

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Demonstrates how to use the `SearchResults` object returned by search queries. It provides typed accessors for common fields like links, titles, and hosts, as well as standard sequence protocols.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        results = await engine.search("tensorflow tutorials", pages=2)

    # Individual field accessors
    print(results.links())   # ['https://...', ...]
    print(results.titles())  # ['TensorFlow - Get Started', ...]
    print(results.hosts())   # ['tensorflow.org', 'youtube.com', ...]
    print(results.text())    # ['An end-to-end open source...', ...]

    # Raw list of dicts
    for item in results.results():
        assert set(item.keys()) == {"host", "link", "title", "text"}

    # Index access and length
    first = results[0]
    print(f"First result: {first['title']} → {first['link']}")
    print(f"Count: {len(results)}")

asyncio.run(main())
```

--------------------------------

### Multiple Search Engines Fan-out

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Runs a query across a specified list of search engines sequentially and merges the results. Allows for custom engine selection and duplicate URL filtering.

```APIDOC
## `MultipleSearchEngines(engines, proxy, timeout)` — Fan-out to many engines

Runs the same query across a named list of engines sequentially and merges all results into a single `SearchResults`. The `engines` parameter is a list of lowercase engine name strings matching keys in `search_engines_dict`.

```python
import asyncio
from search_engines.multiple_search_engines import MultipleSearchEngines

async def main():
    engine = MultipleSearchEngines(["bing", "yahoo", "startpage"])
    engine.ignore_duplicate_urls = True
    async with engine:
        results = await engine.search("climate change research", pages=2)

    print(f"Combined unique results: {len(results)}")
    # Output combined results to a JSON file
    engine.output("json", path="/tmp/climate_results")
    # Creates: /tmp/climate_results.json

asyncio.run(main())
```
```

--------------------------------

### Search with Pagination

Source: https://github.com/soxoj/async-search-scraper/blob/master/README.md

Perform an asynchronous search using the Bing engine and iterate through the results, printing title and link. Supports pagination.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        results = await engine.search("my query", pages=2)
        for item in results:
            print(item["title"], "→", item["link"])

asyncio.run(main())
```

--------------------------------

### Query All Registered Search Engines

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

A convenience class that queries all engines registered in `search_engines_dict`. Useful for maximizing search coverage. Can track banned engines and output results in multiple formats.

```python
import asyncio
from search_engines.multiple_search_engines import AllSearchEngines

async def main():
    engine = AllSearchEngines()
    engine.ignore_duplicate_urls = True
    engine.ignore_duplicate_domains = True
    async with engine:
        results = await engine.search("open source LLM", pages=1)

    print(f"Total unique results across all engines: {len(results)}")
    if engine.banned_engines:
        print(f"Banned/blocked engines: {engine.banned_engines}")
    engine.output("print,csv", path="/tmp/llm_results")
    # Prints to console and writes /tmp/llm_results.csv

asyncio.run(main())
```

--------------------------------

### Search Tor Hidden Services with Torch

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Integrates with the Torch onion search engine via a Tor SOCKS5 proxy. Requires a running Tor daemon, defaulting to localhost:9050. Useful for searching .onion content.

```python
import asyncio
from search_engines import Torch

async def main():
    # Requires: tor service running locally on port 9050
    async with Torch(proxy="socks5://127.0.0.1:9050") as engine:
        results = await engine.search("privacy tools", pages=2)
        for r in results:
            print(r["link"])
        # Expected: .onion URLs returned by Torch
        # http://someonionsite.onion/page ...

asyncio.run(main())
```

--------------------------------

### Aggregate Results from Multiple Search Engines

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Combines search results from a specified list of engines sequentially. Allows for ignoring duplicate URLs across results. Results can be output to various formats.

```python
import asyncio
from search_engines.multiple_search_engines import MultipleSearchEngines

async def main():
    engine = MultipleSearchEngines(["bing", "yahoo", "startpage"])
    engine.ignore_duplicate_urls = True
    async with engine:
        results = await engine.search("climate change research", pages=2)

    print(f"Combined unique results: {len(results)}")
    # Output combined results to a JSON file
    engine.output("json", path="/tmp/climate_results")
    # Creates: /tmp/climate_results.json

asyncio.run(main())
```

--------------------------------

### Override HTTP Headers for Engine Requests

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Use `set_headers` to provide custom HTTP headers for requests made by the search engine. This is useful for setting `User-Agent`, `Accept-Language`, or other required headers.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        engine.set_headers({
            "Accept-Language": "fr-FR,fr;q=0.9",
            "Accept": "text/html,application/xhtml+xml",
        })
        results = await engine.search("intelligence artificielle", pages=1)
        for r in results:
            print(r["title"])

asyncio.run(main())
```

--------------------------------

### All Search Engines Query

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

A convenience subclass that queries every registered search engine. It automatically includes all engines from `search_engines_dict` for maximum coverage.

```APIDOC
## `AllSearchEngines(proxy, timeout)` — Query every registered engine

Convenience subclass of `MultipleSearchEngines` that automatically includes every engine registered in `search_engines_dict`. Useful for maximum coverage in one call.

```python
import asyncio
from search_engines.multiple_search_engines import AllSearchEngines

async def main():
    engine = AllSearchEngines()
    engine.ignore_duplicate_urls = True
    engine.ignore_duplicate_domains = True
    async with engine:
        results = await engine.search("open source LLM", pages=1)

    print(f"Total unique results across all engines: {len(results)}")
    if engine.banned_engines:
        print(f"Banned/blocked engines: {engine.banned_engines}")
    engine.output("print,csv", path="/tmp/llm_results")
    # Prints to console and writes /tmp/llm_results.csv

asyncio.run(main())
```
```

--------------------------------

### Brave Search API Engine

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Integrates with the Brave Search REST API to perform web searches. It supports authentication via an API key and allows fetching results from multiple pages.

```APIDOC
## `Brave(api_key=...)` — Official Brave Search API engine

Queries the Brave Search REST API (`https://api.search.brave.com/res/v1/web/search`) using an API key. Parses JSON responses directly instead of HTML. Supports up to 10 pages (offset 0–9) of 20 results each. The key can be passed as a constructor argument or read from the `BRAVE_API_KEY` environment variable.

```python
import asyncio
import os
from search_engines import Brave

async def main():
    # Key via constructor or env var BRAVE_API_KEY
    async with Brave(api_key=os.environ["BRAVE_API_KEY"]) as engine:
        engine.ignore_duplicate_urls = True
        results = await engine.search("rust programming language", pages=2)

        print(f"Got {len(results)} results")
        for r in results:
            print(r["link"], "|", r["title"])
        # Expected:
        # https://www.rust-lang.org/ | Rust Programming Language
        # https://doc.rust-lang.org/ | The Rust Programming Language - doc.rust-lang.org
        # ...

asyncio.run(main())
```
```

--------------------------------

### Torch Onion Search Engine

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Searches the Torch onion search engine over a Tor SOCKS5 proxy. This is useful for searching `.onion` content and requires a running Tor daemon.

```APIDOC
## `Torch(proxy=...)` — Tor hidden-service search engine

Searches the Torch onion search engine over a Tor SOCKS5 proxy. Defaults to `socks5://127.0.0.1:9050`. Requires a running Tor daemon. Use this to search `.onion` content.

```python
import asyncio
from search_engines import Torch

async def main():
    # Requires: tor service running locally on port 9050
    async with Torch(proxy="socks5://127.0.0.1:9050") as engine:
        results = await engine.search("privacy tools", pages=2)
        for r in results:
            print(r["link"])
        # Expected: .onion URLs returned by Torch
        # http://someonionsite.onion/page ...

asyncio.run(main())
```
```

--------------------------------

### SearchEngine.set_search_operator(operator)

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Filters search results to include only those where the query string appears in specified fields. Supported fields include URL, title, text, and host.

```APIDOC
## `SearchEngine.set_search_operator(operator)` — Filter results

Restricts collected results to only those where the query string appears in one or more specific fields. Supported operators (comma-separated): `url`, `title`, `text`, `host`.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        # Only keep results where the query appears in the URL
        engine.set_search_operator("url,title")
        results = await engine.search("openai", pages=2)
        print(results.links())
        # Expected: only URLs containing "openai" in the link or title
        # ['https://openai.com/', 'https://openai.com/blog/', ...]

asyncio.run(main())
```
```

--------------------------------

### Filter Search Results by Operator

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

Use `set_search_operator` to filter results based on where the query string appears (e.g., 'url', 'title', 'text', 'host'). This method modifies the engine's behavior for subsequent searches.

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        # Only keep results where the query appears in the URL
        engine.set_search_operator("url,title")
        results = await engine.search("openai", pages=2)
        print(results.links())
        # Expected: only URLs containing "openai" in the link or title
        # ['https://openai.com/', 'https://openai.com/blog/', ...]

asyncio.run(main())
```

--------------------------------

### SearchResults Accessor

Source: https://context7.com/soxoj/async-search-scraper/llms.txt

A container object returned by search calls, providing typed accessors for search result fields and standard Python sequence protocols.

```APIDOC
## `SearchResults` — Result collection accessor

Container returned by every `search()` call. Provides typed accessors for each field across all collected results, plus standard Python sequence protocol (`len`, `[]`, iteration).

```python
import asyncio
from search_engines import Bing

async def main():
    async with Bing() as engine:
        results = await engine.search("tensorflow tutorials", pages=2)

    # Individual field accessors
    print(results.links())   # ['https://...', ...]
    print(results.titles())  # ['TensorFlow - Get Started', ...]
    print(results.hosts())   # ['tensorflow.org', 'youtube.com', ...]
    print(results.text())    # ['An end-to-end open source...', ...]

    # Raw list of dicts
    for item in results.results():
        assert set(item.keys()) == {"host", "link", "title", "text"}

    # Index access and length
    first = results[0]
    print(f"First result: {first['title']} → {first['link']}")
    print(f"Count: {len(results)}")

asyncio.run(main())
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.