Whoogle: Self-Hosted Google Search Without the Tracking

Whoogle is a self-hosted meta-search proxy that lets you use Google's search results without Google's tracking, ads, or JavaScript bloat. You get the same results quality — Google's index is legitimately excellent — but stripped of everything that makes Google a privacy nightmare.

Photo by Greg Bulla on Unsplash

This matters more than it sounds. Google logs every search you make, ties it to your account (or browser fingerprint if you're not logged in), and uses it to build an advertising profile. With Whoogle, the search request originates from your server's IP address. Google sees a server somewhere, not you.

How Whoogle Works

Whoogle acts as a middleman. When you search, Whoogle:

1. Sends the query to Google on your behalf
2. Receives Google's HTML response
3. Strips ads, JavaScript, and tracking elements
4. Returns clean, fast results to you

The result is Google search quality with DuckDuckGo-level privacy. You're not searching a separate index — you're getting Google results, just not giving Google anything useful about yourself.

Deploying with Docker

The quickest path to a working Whoogle instance is Docker Compose.

version: '3'
services:
  whoogle:
    image: benbusby/whoogle-search:latest
    container_name: whoogle
    restart: unless-stopped
    ports:
      - "5000:5000"
    environment:
      WHOOGLE_URL_PREFIX: ''
      WHOOGLE_RESULTS_PER_PAGE: 10
      WHOOGLE_CONFIG_LANGUAGE: 'lang_en'
      WHOOGLE_CONFIG_COUNTRY: 'US'
      WHOOGLE_CONFIG_SAFE: '0'
      WHOOGLE_CONFIG_DARK: '1'
    volumes:
      - ./whoogle-config:/config

Start it:

docker-compose up -d

Navigate to http://your-server:5000 and you have a working search engine.

Environment Variables That Matter

Whoogle's behavior is configured almost entirely through environment variables. The most useful ones:

# Appearance
WHOOGLE_CONFIG_DARK=1              # Dark theme
WHOOGLE_RESULTS_PER_PAGE=15        # Results per page (default 10)

# Regional settings
WHOOGLE_CONFIG_LANGUAGE=lang_en    # Interface language
WHOOGLE_CONFIG_COUNTRY=US          # Regional results bias

# Safety
WHOOGLE_CONFIG_SAFE=0              # 0 = off, -2 = strict

# Access control (for public-facing instances)
WHOOGLE_USER=myuser
WHOOGLE_PASS=mypassword

# Tor integration (advanced)
WHOOGLE_ONION_SERVICE=1            # If running as Tor hidden service
WHOOGLE_PROXIES=socks5://tor:9050  # Route searches through Tor

# URL prefix (if serving under a subdirectory)
WHOOGLE_URL_PREFIX=/search

Putting It Behind a Reverse Proxy

For a proper setup, you want HTTPS via a reverse proxy rather than exposing port 5000 directly.

Nginx:

server {
    listen 443 ssl;
    server_name search.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/search.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/search.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Caddy (simpler, auto-TLS):

search.yourdomain.com {
    reverse_proxy localhost:5000
}

Setting Whoogle as Your Default Browser Search Engine

The whole point is making it seamless. You want to type in the address bar and get Whoogle results.

Chrome/Edge:

1. Go to Settings → Search Engine → Manage search engines
2. Click Add
3. Fill in:
   • Name: Whoogle
   • Keyword: w (or whatever)
   • URL: https://search.yourdomain.com/search?q=%s

Firefox:

1. Visit your Whoogle instance
2. Right-click the address bar
3. Select Add "Whoogle" — Firefox auto-detects the search engine from the page

macOS Safari: Safari doesn't support custom search engines natively. Use a browser extension like "Custom Search Engine" to add it.

Restricting Access

If Whoogle is public-facing, you may want to limit who can use it. Whoogle has built-in basic auth:

WHOOGLE_USER=admin
WHOOGLE_PASS=yourpassword

But basic auth over HTTP isn't great. Better options:

IP allowlist via Nginx:

location / {
    allow 10.0.0.0/8;      # Local network
    allow 100.64.0.0/10;   # VPN range
    deny all;
    proxy_pass http://localhost:5000;
}

Authelia or Authentik: Put SSO in front of Whoogle the same way you'd protect any other internal service. Then Whoogle stays wide open internally but requires login from outside.

Whoogle vs Alternatives

SearXNG is a more complex alternative that aggregates multiple search engines. It's better if you want multiple backends (Bing, DuckDuckGo, Brave, Google all at once) and don't mind more configuration complexity. If you just want "Google, but private", Whoogle is simpler and faster.

Handling Google's Anti-Bot Measures

Google occasionally blocks Whoogle instances when they see too many requests from the same IP. This is the main operational headache.

Signs you're being blocked:

• Results return empty or show a CAPTCHA
• Error messages mentioning automated queries
• Requests to solve reCAPTCHAs

Mitigation options:

1. Tor proxying — Route Whoogle's requests through Tor. Slower, but highly effective. Add WHOOGLE_PROXIES=socks5://tor:9050 and run a Tor service alongside.

2. Use a VPN IP — If you have a VPN with rotating IPs or residential IPs, route Whoogle's outbound through it.

3. Self-impose rate limiting — WHOOGLE_RESULTS_PER_PAGE and usage patterns affect how aggressively Google rate-limits. Personal use rarely triggers it.

4. Run multiple instances — A basic load balancer across two or three Whoogle containers distributes the IP footprint.

For personal use on a home server, plain Whoogle without Tor works fine. Google's bot detection is tuned for high-volume scraping — one person's searches don't register.

Useful Features You Might Not Know About

Search operators work: All Google operators work through Whoogle. site:, filetype:, "exact phrase", -exclude, before:, after: — everything.

Image search: Works out of the box. Click Images in the tab bar.

News tab: Available and functional.

Safe search toggle: Accessible from the settings gear icon on the results page, or configured globally via environment variable.

No JavaScript mode: Whoogle works in browsers with JavaScript disabled. This is intentional and unusual — most modern web apps collapse without JS. Whoogle's server-side rendering means it works in Lynx, w3m, or any browser.

Running on a Raspberry Pi

Whoogle runs comfortably on a Raspberry Pi 4 or newer. The lightweight Python Flask app doesn't need much memory — 256MB is enough under normal use.

# Pull the ARM image
docker pull benbusby/whoogle-search:latest

# Same docker-compose.yml works on ARM
docker-compose up -d

Response times are slightly slower than on a proper server (500–800ms vs 200–400ms), but perfectly usable for personal search.

Keeping Whoogle Updated

Whoogle gets updates periodically when Google changes its HTML structure (breaking parsing) or when new features land.

# Update to latest
docker-compose pull
docker-compose up -d

# Or with Watchtower for automatic updates
docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower --interval 86400

The Practical Result

After running Whoogle for a few weeks, the workflow change is invisible — you just search normally. The only differences you notice are the absence of ads and the absence of "sponsored" results that look like real results but aren't.

For self-hosters who want privacy without sacrificing search quality, Whoogle is one of the easier wins. The setup takes about fifteen minutes and the operational burden is essentially zero. If it goes down, you still have Google as a fallback — but once you have Whoogle, you'll rarely want to use Google directly.