Self-Hosted Search Engines in 2026 — SearXNG vs Whoogle Complete Guide

Google knows what you search for. Every query you type, every link you click, every ad you ignore — it all feeds into a massive profile about you. For many self-hosters, that’s unacceptable. The good news? You can run your own private search engine that aggregates results from multiple sources without tracking you.

In this guide, we’ll compare the two most popular self-hosted search solutions in 2026: SearXNG and Whoogle. Both offer privacy-focused search, but they take different approaches. We’ll cover features, performance, Docker setup, and help you choose the right one for your homelab.

Why Self-Host a Search Engine?

Before diving into the comparison, let’s clarify what these tools actually do. Neither SearXNG nor Whoogle crawl the web themselves — that would require massive infrastructure. Instead, they act as privacy-respecting proxies to existing search engines.

Here’s what you gain by self-hosting your search:

• Zero tracking: No search history, no user profiles, no behavioral targeting
• No filter bubbles: Results aren’t personalized based on past behavior
• IP privacy: Search engines see your server’s IP, not yours
• No ads (or at least, no targeted ads based on your searches)
• Complete control: You decide which engines to query and how results are aggregated
• Censorship resistance: Bypass regional restrictions and content filtering

The trade-off? You lose some conveniences like search history sync and personalized results. For privacy-conscious users, that’s a feature, not a bug.

SearXNG Overview

SearXNG is a fork of the original SearX project, developed by the community after the original went unmaintained. It’s a metasearch engine that queries multiple search engines and aggregates results into a single, privacy-respecting interface.

Key Features

• Multi-engine aggregation: Queries Google, Bing, DuckDuckGo, Wikipedia, Reddit, GitHub, and 70+ other sources simultaneously
• Highly customizable: Configure which engines to use, adjust weights, enable/disable specific categories
• Themes and plugins: Modern UI with dark mode, customizable search preferences
• No JavaScript required: Works perfectly with JS disabled (though the experience is better with it enabled)
• Instance privacy: Can disable logs, metrics, and cookies entirely
• Tor-friendly: Works over Tor, supports onion services
• API access: JSON API for programmatic searches
• Result preferences: Save preferences locally (not on server) via browser cookies or URL parameters

Performance

SearXNG is fast when properly configured. Because it queries multiple engines in parallel, response times typically range from 0.5 to 2 seconds depending on:

• Which engines you enable (some are slower than others)
• Your server’s network connectivity
• Whether you’re using rate-limiting or caching

The resource footprint is light: ~150-300 MB RAM for a typical instance.

Privacy Model

SearXNG’s privacy approach is thorough:

• No logs by default (can be enabled for debugging)
• No cookies required (preferences stored client-side or in URL)
• Removes tracking parameters from result URLs
• No user identification — each search is anonymous
• Configurable forwarding: Can proxy images and results to prevent leakage

Whoogle Overview

Whoogle takes a simpler approach: it’s a lightweight, privacy-respecting proxy specifically for Google Search. The name is a portmanteau of “private” + “Google.”

Key Features

• Google-only interface: Mimics Google’s search experience without the tracking
• Minimal and fast: Extremely lightweight, single-purpose design
• No JavaScript required: Fully functional with JS disabled
• Ad-free: Strips all ads from Google results
• Dark mode: Built-in dark theme support
• Result filtering: Remove specific domains or keywords from results
• Custom bangs: DDG-style bang shortcuts (!w for Wikipedia, etc.)
• Tor support: Works seamlessly over Tor
• Image and video search: Proxy Google Images and Videos privately
• Search shortcuts: Quick access to Maps, News, Books, and more

Performance

Whoogle is fast. Because it only queries Google (the fastest search engine), response times are typically under 1 second. The resource footprint is minimal: ~50-100 MB RAM.

The simplicity is intentional — Whoogle does one thing well.

Privacy Model

Whoogle strips all tracking from Google searches:

• No cookies sent to Google
• No user agent tracking
• No search history stored
• Removes AMP links (loads original sites instead)
• Blocks JavaScript tracking
• Proxies images to prevent Google from seeing which results you click

SearXNG vs Whoogle: Feature Comparison

When to Choose SearXNG

Choose SearXNG if you:

• Want diverse sources: Aggregating multiple engines gives broader results
• Value customization: You want fine-grained control over search behavior
• Need specialized searches: Academic papers, GitHub repos, torrent sites, etc.
• Want API access: For automation or integration with other tools
• Prefer open ecosystems: More sources mean less dependence on Google

SearXNG is the power-user choice. It’s more complex to configure but far more versatile.

When to Choose Whoogle

Choose Whoogle if you:

• Prefer Google’s results: You like Google’s search quality, just not the tracking
• Want simplicity: Minimal config, fast setup, low maintenance
• Need speed: Single-query searches are consistently faster
• Run on limited hardware: Lower resource usage matters
• Don’t need variety: Google’s index is comprehensive enough for you

Whoogle is the pragmatist’s choice — maximum privacy with minimal effort.

Setting Up SearXNG with Docker

Here’s a production-ready Docker Compose setup for SearXNG.

Prerequisites

• Docker and Docker Compose installed
• A reverse proxy setup (Traefik, Caddy, or nginx) for HTTPS
• Basic Linux server (even a budget mini PC works great)

Docker Compose File

Create docker-compose.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

version: "3.8"

services:
  searxng:
    image: searxng/searxng:latest
    container_name: searxng
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./searxng:/etc/searxng:rw
    environment:
      - SEARXNG_BASE_URL=https://search.yourdomain.com
      - SEARXNG_SECRET_KEY=${SEARXNG_SECRET_KEY}
    networks:
      - searxng
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

networks:
  searxng:
    driver: bridge

Generate Secret Key

1

openssl rand -hex 32

Add it to a .env file:

SEARXNG_SECRET_KEY=your_generated_key_here

Configuration File

Create searxng/settings.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use_default_settings: true

server:
  secret_key: "${SEARXNG_SECRET_KEY}"
  limiter: true
  image_proxy: true
  port: 8080
  bind_address: "0.0.0.0"

ui:
  default_locale: "en"
  theme_args:
    simple_style: dark
  default_theme: simple
  infinite_scroll: true

search:
  safe_search: 0
  autocomplete: "google"
  default_lang: "en"
  formats:
    - html
    - json

engines:
  - name: google
    disabled: false
    weight: 1.0
  - name: duckduckgo
    disabled: false
    weight: 0.8
  - name: wikipedia
    disabled: false
    weight: 1.0
  - name: github
    disabled: false
    weight: 0.7

enabled_plugins:
  - 'Hash plugin'
  - 'Self Information'
  - 'Tracker URL remover'
  - 'Ahmia blacklist'

redis:
  url: false

Launch

1

docker-compose up -d

Access SearXNG at http://localhost:8080. Configure your reverse proxy to expose it securely over HTTPS.

Customization Tips

• Enable more engines: Edit settings.yml and set disabled: false for engines like Bing, Brave, Qwant, etc.
• Adjust weights: Higher weights prioritize certain engines in aggregated results
• Privacy hardening: Set limiter: true and image_proxy: true in the server block
• Disable telemetry: Ensure no outbound analytics are enabled in settings.yml

Setting Up Whoogle with Docker

Whoogle is even simpler to deploy.

Docker Compose File

Create docker-compose.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

version: "3.8"

services:
  whoogle:
    image: benbusby/whoogle-search:latest
    container_name: whoogle
    restart: unless-stopped
    ports:
      - "5000:5000"
    environment:
      - WHOOGLE_CONFIG_DISABLE=0
      - WHOOGLE_CONFIG_DARK=1
      - WHOOGLE_CONFIG_THEME=dark
      - WHOOGLE_CONFIG_URL=https://search.yourdomain.com
      - WHOOGLE_CONFIG_GET_ONLY=1
      - WHOOGLE_CONFIG_NEW_TAB=1
      - WHOOGLE_CONFIG_VIEW_IMAGE=1
      - WHOOGLE_CONFIG_BLOCK=pinterest.com,quora.com
    volumes:
      - ./whoogle:/config
    networks:
      - whoogle
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

networks:
  whoogle:
    driver: bridge

Environment Variables Explained

• WHOOGLE_CONFIG_DARK=1: Enable dark mode by default
• WHOOGLE_CONFIG_GET_ONLY=1: Use GET requests (better for privacy over Tor)
• WHOOGLE_CONFIG_NEW_TAB=1: Open results in new tabs
• WHOOGLE_CONFIG_VIEW_IMAGE=1: Enable direct image viewing
• WHOOGLE_CONFIG_BLOCK: Block specific domains from results (comma-separated)

Launch

1

docker-compose up -d

Access Whoogle at http://localhost:5000.

Customization Tips

• Block sites: Add domains to WHOOGLE_CONFIG_BLOCK to filter out unwanted sites
• Custom CSS: Mount a custom stylesheet in /config for UI tweaks
• DDG bangs: Use !w <query> for Wikipedia, !gh for GitHub, etc.
• Result preferences: Configure via the web UI settings page

Performance Optimization

SearXNG

1. Enable Redis caching: Add a Redis container to cache results
2. Disable slow engines: Some engines (Yacy, Gigablast) can be slow — disable them
3. Tune timeouts: Lower request_timeout values in settings.yml for faster responses
4. Limit concurrent queries: Adjust max_workers to balance speed and server load

Whoogle

1. Use GET requests: Already enabled in the example config
2. Enable caching: Mount a persistent volume for /config to cache preferences
3. Reduce blocked sites: Overly aggressive blocking can slow down result processing
4. Use a CDN: If exposing publicly, put Whoogle behind Cloudflare or similar

Security Hardening

Both engines should run behind HTTPS with a valid certificate. Here are additional hardening steps:

For Both

• Run as non-root: Both images support dropping privileges (already configured in examples)
• Limit network access: Use Docker networks to isolate search containers
• Enable rate limiting: Prevent abuse if exposing publicly
• Use Fail2Ban: Protect against brute-force attacks on the search endpoint
• Disable public access: If personal use only, restrict to local network or VPN

SearXNG-Specific

• Disable unsafe engines: Some engines (like torrent sites) may be risky depending on jurisdiction
• Enable HMAC verification: Prevents result manipulation
• Disable autocomplete: Reduces requests to third-party services

Whoogle-Specific

• Enable GET_ONLY mode: Reduces fingerprinting risk
• Disable config endpoint: Set WHOOGLE_CONFIG_DISABLE=1 to lock preferences

Mobile Access

Both SearXNG and Whoogle work great on mobile browsers. To improve the experience:

SearXNG

• Use the “simple” theme (better for small screens)
• Enable infinite scroll for easier browsing
• Install as a PWA (Progressive Web App) on iOS/Android

Whoogle

• Already mobile-optimized (mimics Google’s mobile UI)
• Minimal JavaScript means fast loading on slower connections
• Install as a PWA for app-like experience

Integrations and Workflows

Browser Integration

Set either engine as your default search:

Firefox:

1. Visit your SearXNG/Whoogle instance
2. Click the address bar
3. Look for “Add Search Engine” at the bottom
4. Select it and set as default

Chrome/Brave:

1. Settings → Search Engine → Manage Search Engines
2. Add new search engine
3. URL: https://your-instance.com/search?q=%s
4. Set as default

Alfred/Raycast (macOS)

Create a custom search workflow:

https://your-instance.com/search?q={query}

API Usage (SearXNG only)

SearXNG provides a JSON API for programmatic access:

1

curl "https://your-searxng.com/search?q=self-hosting&format=json"

This returns structured JSON you can parse in scripts.

Public Instances vs Self-Hosted

Both projects maintain lists of public instances you can use without self-hosting. Why self-host instead?

Advantages of self-hosting:

• Trust: You control the server, no third-party can log your searches
• Performance: Dedicated resources mean faster responses
• Customization: Configure exactly which engines and features you want
• Reliability: No dependence on volunteer-run instances that may go offline
• Learning: Great project for understanding web privacy and containerization

When public instances make sense:

• You don’t have a homelab yet
• You want to test before committing hardware
• You’re okay with trusting a reputable public instance operator

If you choose a public instance, pick one with a clear privacy policy and ideally located in a privacy-friendly jurisdiction.

Troubleshooting Common Issues

SearXNG

Issue: Slow search results

• Fix: Disable slow engines, reduce timeout values, enable Redis caching

Issue: Engine errors in results

• Fix: Some engines require API keys or have rate limits — check logs and disable problematic ones

Issue: No results for certain queries

• Fix: Enable more engines, adjust weights, check if Google/Bing are enabled

Whoogle

Issue: “No results” error

• Fix: Google may be blocking your server’s IP — use a VPN or switch IPs

Issue: Images not loading

• Fix: Ensure WHOOGLE_CONFIG_VIEW_IMAGE=1 and check firewall rules

Issue: Rate limiting errors

• Fix: Google imposes limits — space out searches or use SearXNG instead

Cost Analysis

Running a self-hosted search engine is cheap:

Hardware

• Existing homelab: $0 (marginal electricity cost)
• Dedicated mini PC: $150-300 (one-time)
• Raspberry Pi 4: $50-80 (sufficient for Whoogle, tight for SearXNG)

Network

• Bandwidth: Negligible (search results are small)
• Domain: $10-15/year (optional, use local DNS instead)
• VPN: $0-5/month (optional, if you want to avoid IP blocking)

Total annual cost: $0-60 depending on setup.

Compare that to Google’s business model: they monetize your searches through advertising and data. Your data is worth far more than $60/year to them.

Conclusion: Which Should You Choose?

After testing both extensively, here’s my recommendation:

Choose SearXNG if:

• You want maximum privacy through diversity (multiple engines = less dependence on any single company)
• You value customization and control
• You search for specialized content (academic, code, torrents, etc.)
• You want API access for automation

Choose Whoogle if:

• You’re happy with Google’s results, just not their tracking
• You want the simplest possible setup
• Speed and low resource usage are priorities
• You’re new to self-hosting and want an easy win

Why not both? If you have the resources, run both. Use SearXNG for general searches and Whoogle as a fast fallback when you need Google-quality results quickly. They complement each other well.

Personally, I run SearXNG as my daily driver and keep a Whoogle instance for occasional use when I need Google’s knowledge graph or recent news. The Docker overhead is minimal, and having options is always good.

Final Thoughts

Self-hosting a search engine is one of the most impactful privacy wins you can achieve. Every search you make is a small piece of data about you — your interests, your questions, your concerns. Over time, that data builds a detailed profile.

By running SearXNG or Whoogle, you take that data back. You search on your terms, without surveillance, without ads, without algorithmic manipulation.

It’s not about hiding something. It’s about owning something: your privacy, your data, your digital autonomy.

If you’re already self-hosting Nextcloud, Vaultwarden, or Jellyfin, adding a private search engine is the next logical step. Your homelab becomes more than infrastructure — it becomes digital sovereignty.

Start with Whoogle if you want quick wins. Graduate to SearXNG when you’re ready for more control. Either way, you’ll never look at Google search the same way again.

Have questions about SearXNG or Whoogle? Drop a comment below or reach out on Twitter. Happy searching! 🔍