---
title: "Autoaloja SearXNG: Motor de Búsqueda Privado con Docker"
description: "Autoaloja SearXNG para tener un metabuscador privado y sin rastreo en tu servidor. Instalación paso a paso con Docker, Traefik, Dockge y Dokploy, con caché en Valkey."
date: 2025-07-30
categories: ["self-hosting"]
tags: ["searxng","docker","privacy"]
---
import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";
**Autoaloja SearXNG** y obtendrás un metabuscador privado que se ejecuta en tu propio servidor. SearXNG agrega resultados de Google, DuckDuckGo, Brave, Startpage y hasta 272 servicios de búsqueda más sin rastrear tus consultas. Funciona en un VPS barato con Docker. Sin claves API, sin suscripciones.
A continuación se cubren tres vías de despliegue: Docker Compose independiente, Traefik con Dockge y Dokploy. Cada una te da una instancia funcional en menos de 15 minutos.
## ¿Qué es SearXNG y cómo funciona el metabuscador?
**SearXNG** es un metabuscador de código abierto, un fork del proyecto Searx original con desarrollo activo y una comunidad más grande. A diferencia de los buscadores que rastrean a los usuarios, SearXNG consulta varios motores de búsqueda al mismo tiempo preservando el anonimato. Tus consultas son anónimas para los buscadores: ven la IP de tu VPS, no la tuya.
Consulta el [repositorio de GitHub](https://github.com/searxng/searxng) (más de 34k estrellas, AGPL-3.0) y la [documentación oficial](https://docs.searxng.org/) para ver el panorama completo.
### Beneficios clave de SearXNG
- **Sin rastreo ni perfiles**: No crea perfiles de usuario ni vende datos a terceros
- **Resultados agregados**: Combina resultados de hasta 272 servicios de búsqueda (245 motores, 88 activados por defecto)
- **Personalizable**: Elige qué motores de búsqueda incluir y configura las preferencias por categoría
- **Código abierto**: Código totalmente auditable bajo AGPL-3.0 con desarrollo comunitario activo
- **Soporte multilingüe**: Disponible en numerosos idiomas con resultados localizados
- **API JSON para automatización**: Consulta programáticamente para agentes de IA, pipelines RAG y flujos de trabajo de n8n
### Cómo funciona SearXNG
SearXNG utiliza una arquitectura de metabúsqueda que actúa como proxy de privacidad entre ti y los motores de búsqueda:
| Componente | Función | Beneficio |
|-----------|----------|---------|
| **Distribución de consultas** | Envía tu búsqueda a varios motores simultáneamente | Resultados completos de fuentes diversas |
| **Agregación de resultados** | Combina y deduplica las respuestas | Conjunto de resultados unificado y clasificado |
| **Capa de proxy de privacidad** | Actúa como intermediario; los motores ven a SearXNG, no a ti | Búsqueda anónima |
| **Motor de personalización** | Filtra los resultados según tus preferencias | Personalización sin creación de perfiles |
> Para más aplicaciones autoalojadas útiles, consulta nuestra guía sobre [contenedores Docker para servidores domésticos](/es/contenedores-docker-servidor-casa/).
## ¿Por qué autoalojar SearXNG? (Privacidad, coste, control)
Existen instancias públicas de SearXNG: [searx.space](https://searx.space/) lista unas 74 en línea ahora mismo. Pero vienen con inconvenientes: limitación de tasa, API JSON desactivada, la selección de motores de otra persona y ninguna garantía de que el operador no registre las consultas.
Cuando autoalojas:
- **Privacidad**: Tú controlas el servidor, la configuración y los registros (o su ausencia). Ningún tercero ve tu historial de búsqueda.
- **Coste**: SearXNG + Valkey cabe en 1-2 GB de RAM. Eso es un VPS de 4-6 $/mes. Sin claves API, sin tarifas por consulta.
- **Control**: Tú eliges los motores, activas la API JSON para tus agentes de IA, estableces límites de tasa y personalizas la interfaz.
Una instancia privada (limiter desactivado, sin el flag `public_instance`) está bien para uso en solitario. Si quieres compartirla con otros o hacerla pública, necesitas el limiter activado — consulta la [sección de instancia pública](#de-instancia-privada-a-instancia-pública-de-searxng-limiter-y-protección-contra-bots) más abajo.
## Requisitos previos: qué necesitas para autoalojar SearXNG
SearXNG + Valkey es ligero. 2 núcleos de CPU y 2 GB de RAM son suficientes para uso personal. No sobreaprovisiones.
- **VPS o servidor dedicado**: Una plataforma de alojamiento fiable. Recomendamos [Hetzner](https://go.bitdoze.com/hetzner) para VPS europeos asequibles o [Hostinger](https://go.bitdoze.com/hostinger-vps) para VPS KVM económicos con almacenamiento NVMe. Mínimo: 2 núcleos de CPU, 2 GB de RAM, 20 GB de almacenamiento. Alternativa: un [mini PC GMKtec M5 Ultra](/go/gmktec-m5-ultra/) para alojar un servidor doméstico local.
- **Docker Engine y Docker Compose**: Las últimas versiones estables instaladas en tu servidor
- **Nombre de dominio**: Un dominio o subdominio que apunte a tu servidor (p. ej., `search.yourdomain.com`)
- **Proxy inverso** (para acceso HTTPS):
- **Opción A**: Traefik con Docker — sigue la [guía de proxy inverso con Traefik](/traefik-proxy-docker/)
- **Opción B**: Traefik con certificados wildcard de Let's Encrypt — consulta la [configuración de certificado wildcard de Traefik](/traefik-wildcard-certificate/)
- **Gestión de contenedores** (opcional): [tutorial de instalación de Dockge](/es/instalar-dockge/) para una gestión simplificada de Docker, o [Dokploy](/dokploy-install/) para despliegue con interfaz gráfica. Consulta los [mejores paneles de servidores autoalojados en 2026](/best-self-hosted-panels/) para más opciones.
_Los precios de los VPS subieron en todos los proveedores en 2026 — si estás reconsiderando un servidor alquilado, consulta [qué cambió y cuándo gana un mini PC](/es/subidas-precios-vps/)._
## Opción de instalación 1: SearXNG con Docker y Docker Compose (independiente)
Esta es la vía de instalación principal, que usa la plantilla oficial de Compose del repositorio de SearXNG.
Las imágenes de contenedor de julio de 2025 en adelante (etiqueta `2025.7.4-01be261` y posteriores) ejecutan **Granian** en lugar de uWSGI. Las antiguas variables de entorno `UWSGI_WORKERS` y `UWSGI_THREADS` no hacen nada, así que no las configures. La documentación oficial dice que "no se aconseja modificar la cantidad de workers". Escala horizontalmente añadiendo réplicas detrás de tu proxy inverso si lo necesitas.
### Paso 1: crea el directorio del proyecto
```bash
mkdir -p ~/searxng && cd ~/searxng
```
### Paso 2: descarga la plantilla oficial de Compose y configura .env
Descarga el archivo de Compose oficial y la plantilla de entorno:
```bash
curl -fsSL -O https://raw.githubusercontent.com/searxng/searxng/master/container/docker-compose.yml \
-O https://raw.githubusercontent.com/searxng/searxng/master/container/.env.example
```
Crea tu archivo `.env` a partir del ejemplo:
```bash
cp .env.example .env
```
Edita `.env` y establece tus valores:
```bash
SEARXNG_VERSION=latest
SEARXNG_HOST=0.0.0.0
SEARXNG_PORT=8080
```
Ahora añade un healthcheck y la URL de Valkey al Compose. La plantilla oficial no incluye un healthcheck, así que añade uno. Tu `docker-compose.yml` final debería verse así:
```yaml
name: searxng
services:
core:
container_name: searxng-core
image: docker.io/searxng/searxng:latest
restart: always
env_file: ./.env
environment:
- SEARXNG_BASE_URL=http://localhost:8080
- SEARXNG_REDIS_URL=valkey://valkey:6379/0
volumes:
- ./core-config/:/etc/searxng/:Z
- core-data:/var/cache/searxng/
ports:
- "${SEARXNG_PORT:-8080}:${SEARXNG_PORT:-8080}"
depends_on:
valkey:
condition: service_healthy
healthcheck:
test: ["CMD", "python3", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://localhost:8080/healthz', timeout=5).status==200 else 1)"]
interval: 30s
timeout: 5s
retries: 3
start_period: 40s
valkey:
container_name: searxng-valkey
image: docker.io/valkey/valkey:9-alpine
command: valkey-server --save 30 1 --loglevel warning
restart: always
volumes:
- valkey-data:/data/
healthcheck:
test: ["CMD", "valkey-server", "--version"]
interval: 10s
timeout: 5s
retries: 3
start_period: 10s
volumes:
core-data:
valkey-data:
```
Si alcanzas el límite de tasa de descargas no autenticadas de Docker Hub, cambia la imagen al mirror de GitHub Container Registry: `ghcr.io/searxng/searxng:latest`. Misma imagen, registro distinto.
En el primer arranque, el entrypoint genera automáticamente `core-config/settings.yml` a partir de una plantilla si el archivo no existe. Establece `use_default_settings: true`, `image_proxy: true` y un `secret_key` aleatorio. No necesitas crear este archivo manualmente.
### Paso 3: inicia y verifica SearXNG
```bash
docker compose up -d
```
Verifica que ambos contenedores estén en ejecución:
```bash
docker compose ps
```
Deberías ver `searxng-core` y `searxng-valkey` con estado `Up` (o `healthy`).
Comprueba el endpoint de salud:
```bash
curl -f http://localhost:8080/healthz
```
Esperado: respuesta HTTP 200. Si obtienes un "connection refused", revisa los registros:
```bash
docker compose logs -f core
```
Busca una línea como `SearXNG ` en la salida de arranque.
Tu instancia de SearXNG está en ejecución en `http://localhost:8080`. Puedes empezar a buscar de inmediato. Para acceso HTTPS, continúa con la opción 2 o 3 a continuación.
**Modos de fallo:**
- **Puerto 8080 ya en uso**: Cambia `SEARXNG_PORT` en tu archivo `.env`.
- **Permiso denegado en `core-config/`**: El contenedor se ejecuta como uid 977. El entrypoint establece `FORCE_OWNERSHIP=true` y hace chown al inicio, lo que normalmente se resuelve solo. Si no, ejecuta `chown -R 977:977 core-config/`.
- **Bucle de reinicio del contenedor**: Revisa `docker compose logs core` en busca de errores de parseo YAML en `settings.yml`. Elimina `core-config/settings.yml` y reinicia. El entrypoint regenera los valores por defecto.
## Opción de instalación 2: integración con Traefik y Dockge
Esta configuración integra SearXNG con el proxy inverso Traefik y la gestión de contenedores de Dockge. Obtienes cifrado HTTPS, certificados SSL automáticos y una interfaz web de administración.
Asegúrate de tener Traefik y Dockge configurados siguiendo la guía de [configuración de certificado wildcard de Traefik](/traefik-wildcard-certificate/).
### Paso 1: prepara la red de Traefik
Verifica que tu red de Traefik exista y créala si es necesario:
```bash
docker network create traefik-net
```
### Paso 2: Docker Compose con etiquetas de Traefik
Crea un `docker-compose.yml` listo para producción con integración de Traefik:
```yaml
name: searxng
networks:
traefik-net:
external: true
services:
core:
container_name: searxng-core
image: docker.io/searxng/searxng:latest
restart: always
environment:
- SEARXNG_PORT=8080
- SEARXNG_BASE_URL=https://search.yourdomain.com
- SEARXNG_REDIS_URL=valkey://valkey:6379/0
volumes:
- ./core-config/:/etc/searxng/:Z
- core-data:/var/cache/searxng/
networks:
- traefik-net
depends_on:
valkey:
condition: service_healthy
healthcheck:
test: ["CMD", "python3", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://localhost:8080/healthz', timeout=5).status==200 else 1)"]
interval: 30s
timeout: 5s
retries: 3
start_period: 40s
labels:
- "traefik.enable=true"
- "traefik.http.routers.searxng.rule=Host(`search.yourdomain.com`)"
- "traefik.http.routers.searxng.entrypoints=https"
- "traefik.http.routers.searxng.tls=true"
- "traefik.http.routers.searxng.tls.certresolver=letsencrypt"
- "traefik.http.services.searxng.loadbalancer.server.port=8080"
valkey:
container_name: searxng-valkey
image: docker.io/valkey/valkey:9-alpine
command: valkey-server --save 30 1 --loglevel warning
restart: always
networks:
- traefik-net
volumes:
- valkey-data:/data/
healthcheck:
test: ["CMD", "valkey-server", "--version"]
interval: 10s
timeout: 5s
retries: 3
start_period: 10s
volumes:
core-data:
valkey-data:
```
Si planeas activar el limiter de SearXNG (instancia pública), Traefik debe pasar `X-Forwarded-For` correctamente. Sin ella, el limiter ve a todos los clientes como la IP del proxy y limita a todo el mundo. Asegúrate de que tu entrypoint de Traefik tenga `forwardedHeaders` configurado, o añade el middleware de cabeceras reenviadas a las etiquetas del router. Consulta la [guía de proxy inverso con Traefik](/traefik-proxy-docker/) para más detalles.
### Paso 3: despliega a través de Dockge
1. Accede a tu interfaz de Dockge (normalmente `https://dockge.yourdomain.com`)
2. Crea un nuevo stack llamado "searxng"
3. Pega la configuración de Docker Compose anterior
4. Personaliza el nombre de dominio en las etiquetas de Traefik
5. Despliega el stack
### Paso 4: configura el DNS y verifica
Apunta tu subdominio a la dirección IP de tu servidor:
| Tipo de registro | Nombre | Valor | TTL |
|-------------|------|-------|-----|
| A | search | ip-de-tu-servidor | 300 |
Espera de 5 a 15 minutos para que los cambios de DNS se propaguen antes de acceder a tu instancia de SearXNG.
Verifica el despliegue:
```bash
curl -f https://search.yourdomain.com/healthz
```
Esperado: HTTP 200 sobre HTTPS.
## Opción de instalación 3: despliegue fácil con Dokploy
Dokploy es la vía más rápida si prefieres una gestión con interfaz gráfica y mínima interacción con la línea de comandos. Tiene plantillas integradas y gestiona la configuración automáticamente.
### Paso 1: instala Dokploy
Si aún no lo has hecho, configura Dokploy en tu servidor siguiendo el [tutorial de instalación de Dokploy](/dokploy-install/). Consulta también los [mejores paneles de servidores autoalojados en 2026](/best-self-hosted-panels/) para una comparativa.
### Paso 2: crea la aplicación SearXNG
1. **Accede al panel de Dokploy**: Navega a tu interfaz de Dokploy
2. **Crea un nuevo proyecto**: Haz clic en "New Project" y llámalo "searxng"
3. **Selecciona la plantilla**: Elige el blueprint "SearXNG" de las plantillas disponibles. El blueprint oficial en el [repositorio de plantillas de Dokploy](https://github.com/Dokploy/templates/tree/canary/blueprints/searxng) usa `searxng/searxng:latest` con `valkey/valkey:8-alpine`, monta `/etc/searxng` y `/var/cache/searxng`, y establece `limiter: false` por defecto.
### Paso 3: configura las variables de entorno
Establece las siguientes variables de entorno en Dokploy:
| Variable | Valor | Descripción |
|----------|-------|-------------|
| `SEARXNG_BASE_URL` | `https://search.yourdomain.com` | Tu URL pública (debe ser HTTPS en producción) |
| `SEARXNG_REDIS_URL` | `valkey://valkey:6379/0` | Conexión a Valkey para caché y limiter |
El blueprint de Dokploy usa por defecto Valkey 8-alpine (no 9) — esto funciona bien. El limiter está desactivado por defecto. Si necesitas protección contra bots, consulta la [sección de instancia pública](#de-instancia-privada-a-instancia-pública-de-searxng-limiter-y-protección-contra-bots).
### Paso 4: configuración del dominio
1. Navega a la sección "Domains" en tu proyecto de Dokploy
2. Añade tu dominio: `search.yourdomain.com`
3. Establece el puerto del contenedor en 8080
4. Activa la generación del certificado SSL/TLS
### Paso 5: despliega la aplicación
Haz clic en el botón "Deploy" y supervisa los registros del despliegue. Dokploy descargará automáticamente las imágenes de Docker, configurará la red, generará los certificados SSL y establecerá las reglas del proxy inverso.
Verifica: accede a tu URL desplegada y comprueba que `https://search.yourdomain.com/healthz` devuelve HTTP 200.
## De instancia privada a instancia pública de SearXNG (limiter y protección contra bots)
Por defecto, tu instancia de SearXNG es privada: sin limitación de tasa, sin detección de bots, sin controles de acceso público. Eso está bien para uso personal. Pero si compartes la URL o la haces pública, los bots la rastrearán y los motores de origen empezarán a devolver errores 429 y CAPTCHAs.
Si eres el único usuario, no necesitas el limiter. Valkey sigue siendo útil para el caché, pero las funciones de detección de bots son opcionales.
Para activar el limiter y el modo de instancia pública, edita `core-config/settings.yml`:
```yaml
use_default_settings: true
server:
secret_key: "change-me-to-a-random-string"
public_instance: true
limiter: true
image_proxy: true
valkey:
url: valkey://valkey:6379/0
```
También puedes crear un `core-config/limiter.toml` opcional para un control más fino:
```toml
[botdetection]
ipv4_prefix = 32
ipv6_prefix = 48
trusted_proxies = ['127.0.0.0/8', '::1']
[botdetection.ip_limit]
link_token = true
[botdetection.ip_lists]
pass_searxng_org = true
```
El `secret_key` autogenerado es aleatorio pero se almacena en texto plano en `settings.yml`. Para despliegues en producción, considera [alternativas seguras a las variables de entorno en texto plano en Docker Compose](/docker-compose-secrets/).
**Requisitos para que el limiter funcione:**
- Valkey debe estar en ejecución y accesible (`valkey.url` configurado)
- Tu proxy inverso debe pasar las cabeceras `X-Forwarded-For` o `X-Real-IP` — de lo contrario, el limiter ve todo el tráfico como si viniera de la IP del proxy
- `server.limiter: true` debe estar establecido en `settings.yml`
## Uso de la API JSON de SearXNG para agentes de IA y automatización
SearXNG expone una API de búsqueda en `/search?q=...&format=json`. Puedes usarla para agentes de IA, pipelines RAG, flujos de trabajo de n8n e integraciones con Open WebUI.
La mayoría de las instancias públicas de SearXNG desactivan la API JSON para evitar abusos. Autoalojar es la forma fiable de obtener acceso programático a la búsqueda.
Para activar la salida JSON, añade esto a `core-config/settings.yml`:
```yaml
search:
formats:
- html
- json
```
Luego consúltala:
```bash
curl 'https://search.yourdomain.com/search?q=bitdoze&format=json'
```
La API también admite los formatos `csv` y `rss`. Sin el ajuste `formats`, solicitar JSON devuelve un 403.
**Casos de uso:**
- Alimentar los resultados de búsqueda a las ventanas de contexto de LLM para RAG
- Impulsar flujos de automatización de n8n o Make.com
- Construir paneles de búsqueda personalizados
- Sustituir las API de búsqueda de pago para tus agentes de IA
Limita la tasa de tus propios agentes — no bombardees los motores de origen. Unas pocas consultas por minuto está bien; cientos por minuto harán que bloqueen la IP de tu VPS.
Para enfoques alternativos de búsqueda web en flujos de trabajo de IA, consulta [búsqueda con DuckDuckGo para agentes de IA sin claves API](/es/busqueda-duckduckgo-openclaw/) o [web scraping vía MCP para agentes de IA](/es/guia-brightdata-mcp/). Como alternativa de API de búsqueda web gestionada, [TinyFish](https://go.bitdoze.com/tinyfish) ofrece infraestructura de búsqueda amigable para agentes. Si necesitas datos web estructurados a escala junto con la búsqueda, [Bright Data](https://go.bitdoze.com/brightdata) ofrece recolección de datos web impulsada por IA.
## Configuración y personalización de SearXNG
### Selección de motores de búsqueda
Navega a **Preferences → Engines** para personalizar tus fuentes de búsqueda. Los motores web activados por defecto son Google, DuckDuckGo, Brave y Startpage. Bing, Yandex y otros están disponibles pero desactivados por defecto.
- **Búsqueda general**: Google, DuckDuckGo, Brave, Startpage (activados); Bing, Yandex, Qwant, Mojeek (disponibles, desactivados por defecto)
- **Fuentes de noticias**: Reuters, Wikinews, además de fuentes regionales como Tagesschau (DE) y Ansa (IT)
- **Académico**: Google Scholar, Semantic Scholar, arxiv, pubmed, OpenAlex (Microsoft Academic fue retirado en 2021)
- **Multimedia**: YouTube, Vimeo, Flickr, Unsplash
- **Compras**: Amazon, eBay, AliExpress
- **Social**: Lemmy, Mastodon, Stack Overflow (Reddit está desactivado por defecto; el motor de Twitter/X se eliminó cuando terminó la API gratuita en 2023)
Usa la sintaxis `!bang` para búsquedas rápidas en motores específicos (p. ej., `!go docker compose` busca solo en Google). Puedes personalizar qué categorías aparecen como pestañas mediante el ajuste `categories_as_tabs`.
### Ajustes de privacidad y seguridad
Configura estas opciones en Preferences o en `settings.yml`:
| Ajuste | Valor recomendado | Propósito |
|---------|------------------|---------|
| **Búsqueda segura** | Moderado | Filtrar contenido inapropiado |
| **Proxy de imágenes** | Activado | Ocultar tu IP de las fuentes de imágenes (activado por defecto en la plantilla) |
| **Método** | GET | Por defecto; POST oculta las consultas del historial del navegador pero rompe el botón de retroceso |
| **Autocompletado** | Desactivado | Evita llamadas a API externas de servicios de sugerencias |
Nota: SearXNG almacena las preferencias de la interfaz en cookies del navegador por diseño — son cookies locales para tus ajustes, no rastreo remoto. Esto es diferente a "ninguna cookie en absoluto".
### Temas y apariencia (tema Simple)
SearXNG incluye un único tema: **simple**. Los temas Oscar y Pix-art se eliminaron en mayo de 2022. Puedes configurar el estilo mediante `simple_style` en los ajustes o en las preferencias de la interfaz:
- `auto` — sigue la preferencia del sistema (claro/oscuro)
- `light`
- `dark`
- `black` — negro puro para pantallas OLED
## Integración con el navegador
### Establecer SearXNG como motor de búsqueda predeterminado
**Para Firefox/LibreWolf:**
1. Navega a `about:preferences#search`
2. Haz clic en "Add Search Engine"
3. Introduce los datos:
- **Nombre**: SearXNG Privacy Search
- **URL**: `https://search.yourdomain.com/search?q=%s`
4. Establécelo como motor de búsqueda predeterminado
**Para Chrome/Chromium:**
1. Ve a Settings → Search engine → Manage search engines
2. Haz clic en "Add" junto a "Other search engines"
3. Rellena:
- **Motor de búsqueda**: SearXNG
- **Palabra clave**: searxng
- **URL**: `https://search.yourdomain.com/search?q=%s`
Establecer SearXNG como tu motor de búsqueda predeterminado dirige todas las búsquedas a través de tu instancia autoalojada, eliminando por completo el rastreo de los buscadores comerciales.
## Monitorización y mantenimiento
### Monitorización de salud
Usa el endpoint `/healthz` para los healthchecks — no una consulta de búsqueda. El antiguo enfoque de consultar `/search?q=test&format=json` es frágil y genera carga innecesaria.
Healthcheck correcto para tu archivo Compose:
```yaml
healthcheck:
test: ["CMD", "python3", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://localhost:8080/healthz', timeout=5).status==200 else 1)"]
interval: 30s
timeout: 5s
retries: 3
start_period: 40s
```
SearXNG también expone endpoints de métricas:
- `/stats` — estadísticas de rendimiento de los motores (activadas por defecto vía `general.enable_metrics`)
- `/stats/errors` — tasas de error por motor (útil para detectar motores rotos tras las actualizaciones)
- `/metrics` — endpoint OpenMetrics opcional para Prometheus (actívalo con el ajuste `open_metrics`)
Considera añadir un [monitor de Uptime Kuma](/uptime-kuma-tool/) para tu endpoint `/healthz` y recibir alertas cuando SearXNG se caiga.
### Actualizar SearXNG
SearXNG es una rolling release — no hay números de versión mayores, solo etiquetas basadas en fechas como `2026.7.7-f69b22c45`. Para actualizar:
```bash
docker compose pull
docker compose up -d
```
Revisa `/stats/errors` después de las actualizaciones — las integraciones de motores pueden romperse entre versiones. Consulta [cómo actualizar contenedores con Docker Compose](/updating-container-docker-compose/) para un flujo de trabajo general.
### Estrategias de copia de seguridad
El único estado obligatorio es tu directorio de configuración. Los datos de Valkey son caché desechable — no les hagas copias de seguridad.
```bash
# Config backup (the only critical state)
tar -czf searxng-backup-$(date +%Y%m%d).tar.gz core-config/
# Favicon/cache state (optional, small)
docker run --rm -v searxng_core-data:/from -v "$PWD":/to alpine sh -c 'cd /from && tar czf /to/searxng-cache-$(date +%Y%m%d).tar.gz .'
```
El volumen de Valkey almacena el estado de limitación de tasa y el caché. Si lo pierdes, SearXNG lo recrea en el próximo arranque. No desperdicies espacio de copias de seguridad en él.
Si pierdes `core-config/settings.yml`, el entrypoint regenera uno por defecto en el próximo arranque — pero tus ajustes personalizados desaparecen. Haz copias de seguridad de `core-config/` con regularidad.
## Resolución de problemas comunes
Los motores de origen limitan la tasa o devuelven CAPTCHAs cuando detectan tráfico inusual. Este es el problema más común.
**Soluciones:**
1. Activa el limiter si tu instancia es pública (consulta la [sección de instancia pública](#de-instancia-privada-a-instancia-pública-de-searxng-limiter-y-protección-contra-bots))
2. Desactiva los motores problemáticos en Preferences → Engines
3. Revisa las tasas de error de los motores en `/stats/errors`
4. Espera — algunas limitaciones de tasa son temporales (de minutos a horas)
Consulta la [discusión de GitHub #5651](https://github.com/searxng/searxng/discussions/5651) para informes actualizados sobre la fiabilidad de los motores.
El limiter lee la IP del cliente de `X-Forwarded-For` / `X-Real-IP`. Si Traefik no reenvía las cabeceras correctamente, todos los clientes aparecen como la IP del proxy y la limitación de tasa bloquea a todo el mundo.
**Solución:** Asegúrate de que tu entrypoint de Traefik tenga `forwardedHeaders` configurado. Consulta la [guía de proxy inverso con Traefik](/traefik-proxy-docker/) para la sintaxis correcta de las etiquetas.
Revisa `docker compose logs core` en busca de errores de parseo YAML en `settings.yml`. Causas comunes: indentación incorrecta, claves inválidas o artefactos de copiar y pegar.
**Solución:** Elimina `core-config/settings.yml` y reinicia. El entrypoint regenera los valores por defecto:
```bash
rm core-config/settings.yml
docker compose restart core
docker compose logs -f core
```
Busca la línea de arranque `SearXNG ` para confirmar que se recuperó.
**Síntomas:** Errores de HTTPS o advertencias de certificado.
**Soluciones:**
1. Verifica que la configuración DNS del dominio apunte a la IP de tu servidor
2. Revisa los registros de generación de certificados de Traefik: `docker compose logs traefik`
3. Reinicia el contenedor de Traefik
4. Valida los ajustes del resolvedor de certificados en la configuración de Traefik
## Mejores prácticas de seguridad
### Seguridad de red
- **Configuración del firewall**: Bloquea los puertos innecesarios, permite solo el tráfico HTTP/HTTPS (puertos 80, 443)
- **Acceso por VPN**: Para instancias privadas, considera restringir el acceso a través de una VPN en lugar de exponerla a internet
- **Actualizaciones regulares**: Mantén las imágenes de Docker y el sistema anfitrión actualizados — SearXNG es una rolling release con correcciones frecuentes
- **No expongas la API JSON** a internet público a menos que la necesites específicamente
- **Mantén `debug: false`** en los ajustes de producción
Para un endurecimiento completo del VPS, consulta [cómo securizar tu VPS con CrowdSec](/crowdsec-secure-server/).
### Seguridad de la aplicación
- **Cambia el `secret_key` autogenerado** en `settings.yml` por un valor aleatorio fuerte
- **Establece `SEARXNG_BASE_URL`** en tu URL HTTPS final — las URL que no coinciden causan bucles de redirección y rompen el proxy de imágenes
- **Usa el mirror de GHCR** (`ghcr.io/searxng/searxng`) si los límites de tasa de Docker Hub afectan a tus descargas
- **Para instancias públicas**: activa el limiter, establece `public_instance: true`, configura `limiter.toml` con proxies de confianza
Añade un firewall DNS como [NextDNS](https://go.bitdoze.com/nextdns) para una capa extra de privacidad y bloqueo de anuncios a nivel de red.
### Protección de datos
| Componente | Medida de seguridad | Implementación |
|-----------|-----------------|----------------|
| **Consultas de búsqueda** | Sin registros | Comportamiento por defecto de SearXNG — nada se escribe en disco |
| **Preferencias de usuario** | Solo cookies locales | Almacenadas en el navegador, no en el servidor |
| **Estado de caché/limitación** | Valkey (opcional) | Solo necesario para el limiter; datos desechables |
| **SSL/TLS** | Cifrado fuerte | Certificados de Let's Encrypt vía Traefik |
## Conclusión
Autoalojar SearXNG te da un metabuscador privado que agrega resultados de hasta 272 servicios de búsqueda, funcionando en un VPS de 4-6 $/mes con Docker. Sin rastreo, sin claves API, sin suscripciones.
- **Privacidad completa**: Sin rastreo, perfiles ni recolección de datos
- **Diversidad de búsqueda**: Resultados de Google, DuckDuckGo, Brave y más de 270 servicios adicionales
- **API JSON**: Búsqueda programática para agentes de IA, pipelines RAG y automatización
- **Tres vías de despliegue**: Docker independiente, Traefik + Dockge o Dokploy
- **Bajo coste**: Funciona cómodamente en un VPS de 2 GB de RAM
Empieza con la opción 1 (Docker Compose independiente) para tenerlo funcionando en minutos. Añade Traefik para HTTPS cuando estés listo para usarlo como tu buscador diario. Activa la API JSON cuando quieras alimentar los resultados de búsqueda a tus flujos de trabajo de IA.
**¿Quieres ampliar tu stack autoalojado?** Consulta nuestras guías sobre [Dockge para la gestión de contenedores Docker](/es/instalar-dockge/), [configuración del proxy inverso Traefik](/traefik-proxy-docker/) y [despliegue en la plataforma Dokploy](/dokploy-install/).
*Verificado con la rolling release 2026.x de SearXNG, versión de documentación 2026.8.29.*