> ## Documentation Index
> Fetch the complete documentation index at: https://firecrawl-claude-eager-dijkstra-dne9il.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Búsqueda

> Busca en la web y obtén el contenido completo de los resultados

Busca en la web y obtén contenido limpio y estructurado de cada resultado en una sola llamada a la API. Envía una consulta a `/search` y Firecrawl devuelve títulos, descripciones y URLs. Agrega `scrapeOptions` para recuperar también el markdown completo de la página, HTML, links o capturas de pantalla de cada resultado.

Los resultados de búsqueda incluyen [highlights](/es/features/search-highlights) relevantes para la consulta de forma predeterminada. Establece `highlights` en `false` cuando quieras en su lugar la descripción simple o el fragmento de cada sitio web.

Para ver la lista completa de parámetros, consulta la [referencia de la API del endpoint Search](https://docs.firecrawl.dev/api-reference/endpoint/search).

<Card title="Pruébalo en el Playground" icon="play" href="https://www.firecrawl.dev/playground?endpoint=search">
  Prueba buscar en el playground interactivo; no necesitas escribir código.
</Card>

<div id="performing-a-search-with-firecrawl">
  ## Buscar con Firecrawl
</div>

<div id="search-endpoint">
  ### punto de conexión /search
</div>

Se usa para realizar búsquedas en la web y, opcionalmente, obtener contenido de los resultados.

<div id="installation">
  ### Instalación
</div>

<CodeGroup>
  ```python Python theme={null}
  # pip install firecrawl-py

  from firecrawl import Firecrawl

  firecrawl = Firecrawl(
    # No se necesita API key para comenzar — agrega una para límites de tasa más altos:
    # api_key="fc-YOUR-API-KEY",
  )
  ```

  ```js Node theme={null}
  // npm install firecrawl

  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({
    // No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
    // apiKey: "fc-YOUR-API-KEY",
  });
  ```

  ```bash CLI theme={null}
  # Instalar globalmente con npm
  npm install -g firecrawl

  # Autenticar (configuración de una sola vez)
  firecrawl login
  ```
</CodeGroup>

<div id="basic-usage">
  ### Uso básico
</div>

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  firecrawl = Firecrawl(
    # No se necesita API key para comenzar — agrega una para límites de tasa más altos:
    # api_key="fc-YOUR-API-KEY",
  )

  results = firecrawl.search(
      query="firecrawl",
      limit=3,
  )
  print(results)
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({
    // No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
    // apiKey: "fc-YOUR-API-KEY",
  });

  const results = await firecrawl.search('firecrawl', {
    limit: 3,
    scrapeOptions: { formats: ['markdown'] }
  });
  console.log(results);
  ```

  ```bash cURL theme={null}
  # No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para límites de tasa más altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/search" \
    -H "Content-Type: application/json" \
    -d '{
      "query": "firecrawl",
      "limit": 3
    }'
  ```

  ```bash CLI theme={null}
  # Buscar en la web
  firecrawl search "firecrawl web scraping" --limit 5 --pretty
  ```
</CodeGroup>

<div id="response">
  ### Respuesta
</div>

Los SDKs devuelven directamente el objeto de datos. cURL devuelve la carga útil completa.

```json JSON theme={null}
{
  "success": true,
  "data": {
    "web": [
      {
        "url": "https://www.firecrawl.dev/",
        "title": "Firecrawl - The Web Data API for AI",
        "description": "The web crawling, scraping, and search API for AI. Built for scale. Firecrawl delivers the entire internet to AI agents and builders.",
        "position": 1
      },
      {
        "url": "https://github.com/firecrawl/firecrawl",
        "title": "mendableai/firecrawl: Turn entire websites into LLM-ready ... - GitHub",
        "description": "Firecrawl is an API service that takes a URL, crawls it, and converts it into clean markdown or structured data.",
        "position": 2
      },
      ...
    ],
    "images": [
      {
        "title": "Quickstart | Firecrawl",
        "imageUrl": "https://mintlify.s3.us-west-1.amazonaws.com/firecrawl/logo/logo.png",
        "imageWidth": 5814,
        "imageHeight": 1200,
        "url": "https://docs.firecrawl.dev/",
        "position": 1
      },
      ...
    ],
    "news": [
      {
        "title": "Y Combinator startup Firecrawl is ready to pay $1M to hire three AI agents as employees",
        "url": "https://techcrunch.com/2025/05/17/y-combinator-startup-firecrawl-is-ready-to-pay-1m-to-hire-three-ai-agents-as-employees/",
        "snippet": "It's now placed three new ads on YC's job board for “AI agents only” and has set aside a $1 million budget total to make it happen.",
        "date": "3 months ago",
        "position": 1
      },
      ...
    ]
  }
}
```

<Note>
  **Si usas los SDKs:** los resultados de búsqueda se agrupan por tipo de fuente, no en un array genérico `.data`. Accede a los resultados web con `result.web`, a las noticias con `result.news` y a las imágenes con `result.images`.

  ```python Python theme={null}
  result = firecrawl.search("query")
  for item in result.web or []:
      print(item.url, item.title)
  ```

  ```js JavaScript theme={null}
  const result = await firecrawl.search("query");
  for (const item of result.web ?? []) {
    console.log(item.url, item.title);
  }
  ```
</Note>

<div id="search-result-types">
  ## Tipos de resultados de búsqueda
</div>

Además de los resultados web habituales, Search admite tipos de resultados especializados mediante el parámetro `sources`:

* `web`: resultados web estándar (predeterminado)
* `news`: resultados enfocados en noticias
* `images`: resultados de búsqueda de imágenes

Puedes solicitar varias fuentes en una sola llamada (por ejemplo, `sources: ["web", "news"]`). Cuando lo haces, el parámetro `limit` se aplica **por tipo de fuente**; así, `limit: 5` con `sources: ["web", "news"]` devuelve hasta 5 resultados web y hasta 5 resultados de noticias (10 en total). Si necesitas parámetros diferentes por fuente (por ejemplo, valores `limit` distintos o diferentes `scrapeOptions`), haz llamadas separadas en su lugar.

<div id="search-categories">
  ## Categorías de búsqueda
</div>

Filtra los resultados por categorías específicas usando el parámetro `categories`:

* `github`: Busca en repositorios, código, issues y documentación de GitHub
* `research`: Busca en sitios académicos y de investigación (arXiv, Nature, IEEE, PubMed, etc.)
* `pdf`: Busca archivos PDF

<div id="github-category-search">
  ### Búsqueda de categorías en GitHub
</div>

Busca específicamente dentro de los repositorios de GitHub:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-TU_API_KEY" \
  -d '{
    "query": "web scraping en Python",
    "categories": ["github"],
    "limit": 10
  }'
```

<div id="research-category-search">
  ### Búsqueda por categoría de investigación
</div>

Busca en sitios web académicos y de investigación:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-TU_API_KEY" \
  -d '{
    "query": "transformers de aprendizaje automático",
    "categories": ["investigación"],
    "limit": 10
  }'
```

<div id="mixed-category-search">
  ### Búsqueda de categorías mixtas
</div>

Combina varias categorías en una sola búsqueda:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "redes neuronales",
    "categories": ["github", "investigación"],
    "limit": 15
  }'
```

<div id="domain-filters">
  ## Filtros de dominio
</div>

Usa `includeDomains` para restringir los resultados de búsqueda a dominios específicos, o `excludeDomains` para excluir dominios específicos de la búsqueda. Estos campos añaden internamente los operadores `site:` y `-site:` a la consulta, así que pasa únicamente los dominios, sin protocolo ni ruta.

<Note>
  `includeDomains` y `excludeDomains` son mutuamente excluyentes. Usa uno u otro en una misma solicitud.
</Note>

<div id="include-domains">
  ### Dominios incluidos
</div>

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "web scraping",
    "includeDomains": ["firecrawl.dev", "docs.firecrawl.dev"],
    "limit": 10
  }'
```

<div id="exclude-domains">
  ### Excluir dominios
</div>

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "web scraping tools",
    "excludeDomains": ["example.com"],
    "limit": 10
  }'
```

<div id="category-response-format">
  ### Formato de respuesta de categorías
</div>

Cada resultado de búsqueda incluye un campo `category` que indica su fuente:

```json theme={null}
{
  "success": true,
  "data": {
    "web": [
      {
        "url": "https://github.com/example/neural-network",
        "title": "Implementación de redes neuronales",
        "description": "Implementación de redes neuronales en PyTorch",
        "category": "github"
        "category": "github",
      {
        "url": "https://arxiv.org/abs/2024.12345",
        "title": "Avances en la arquitectura de redes neuronales",
        "description": "Artículo de investigación sobre mejoras en redes neuronales",
        "category": "research"
      }
    ]
  }
}
```

Ejemplos:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-TU_API_KEY" \
  -d '{
    "query": "openai",
    "sources": ["news"],
    "limit": 5
  }'
```

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "jupiter",
    "sources": ["images"],
    "limit": 8
  }'
```

<div id="hd-image-search-with-size-filtering">
  ### Búsqueda de imágenes en HD con filtro de tamaño
</div>

Usa los operadores de imágenes para encontrar imágenes de alta resolución:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "atardecer imagesize:1920x1080",
    "sources": ["images"],
    "limit": 5
  }'
```

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "fondo de pantalla de montaña larger:2560x1440",
    "sources": ["images"],
    "limit": 8
  }'
```

**Resoluciones HD habituales:**

* `imagesize:1920x1080` - Full HD (1080p)
* `imagesize:2560x1440` - QHD (1440p)
* `imagesize:3840x2160` - 4K UHD
* `larger:1920x1080` - HD o superior
* `larger:2560x1440` - QHD o superior

<div id="search-with-content-scraping">
  ## Búsqueda con extracción de contenido
</div>

Busca y recupera contenido de los resultados de búsqueda en una sola operación.

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  firecrawl = Firecrawl(
    # No se necesita API key para comenzar — agrega una para límites de tasa más altos:
    # api_key="fc-YOUR_API_KEY",
  )

  # Buscar y hacer scraping de contenido
  results = firecrawl.search(
      "firecrawl web scraping",
      limit=3,
      scrape_options={
          "formats": ["markdown", "links"]
      }
  )
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({
    // No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
    // apiKey: "fc-YOUR-API-KEY",
  });

  const results = await firecrawl.search('firecrawl', {
    limit: 3,
    scrapeOptions: { formats: ['markdown'] }
  });
  console.log(results);
  ```

  ```bash cURL theme={null}
  # No se necesita API key para comenzar — agrega -H "Authorization: Bearer fc-YOUR_API_KEY" para límites de tasa más altos:
  curl -X POST https://api.firecrawl.dev/v2/search \
    -H "Content-Type: application/json" \
    -d '{
      "query": "firecrawl web scraping",
      "limit": 3,
      "scrapeOptions": {
        "formats": ["markdown", "links"]
      }
    }'
  ```

  ```bash CLI theme={null}
  # Buscar y extraer resultados
  firecrawl search "firecrawl" --scrape --scrape-formats markdown --limit 5 --pretty
  ```
</CodeGroup>

Todas las opciones del punto de conexión /scrape son compatibles con este punto de conexión de búsqueda mediante el parámetro `scrapeOptions`.

<div id="response-with-scraped-content">
  ### Respuesta con contenido rastreado
</div>

```json theme={null}
{
  "success": true,
  "data": [
    {
      "title": "Firecrawl - La API definitiva de web scraping",
      "description": "Firecrawl es una potente API de web scraping que convierte cualquier sitio web en datos limpios y estructurados para IA y análisis.",
      "url": "https://firecrawl.dev/",
      "markdown": "# Firecrawl\n\nLa API definitiva de web scraping\n\n## Convierte cualquier sitio web en datos limpios y estructurados\n\nFirecrawl facilita la extracción de datos de sitios web para aplicaciones de IA, investigación de mercados, agregación de contenido y más...",
      "links": [
        "https://firecrawl.dev/pricing",
        "https://firecrawl.dev/docs",
        "https://firecrawl.dev/guides"
      ],
      "metadata": {
        "title": "Firecrawl - La API definitiva de web scraping",
        "description": "Firecrawl es una potente API de web scraping que convierte cualquier sitio web en datos limpios y estructurados para IA y análisis.",
        "sourceURL": "https://firecrawl.dev/",
        "statusCode": 200
      }
    }
  ]
}
```

<div id="search-then-scrape-two-step-pattern">
  ## Buscar y luego hacer scraping (patrón de dos pasos)
</div>

Si necesitas filtrar o procesar los resultados de búsqueda antes de hacer scraping, usa un enfoque de dos pasos: primero busca y luego haz scraping de las URL que quieras.

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  firecrawl = Firecrawl(api_key="fc-YOUR_API_KEY")

  # Paso 1: Buscar
  results = firecrawl.search("firecrawl web scraping", limit=5)

  # Paso 2: Hacer scraping de la URL de cada resultado para obtener el contenido completo
  for item in results.web or []:
      page = firecrawl.scrape(item.url, formats=["markdown"])
      print(page.markdown[:200])
  ```

  ```js JavaScript theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

  const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" });

  // Paso 1: Buscar
  const results = await firecrawl.search("firecrawl web scraping", { limit: 5 });

  // Paso 2: Hacer scraping de la URL de cada resultado para obtener el contenido completo
  for (const item of results.web ?? []) {
    const page = await firecrawl.scrape(item.url, { formats: ["markdown"] });
    console.log(page.markdown?.substring(0, 200));
  }
  ```
</CodeGroup>

<Tip>
  **Cuándo usar cada enfoque:**

  * **Un solo paso** (`scrapeOptions` en search): quieres el contenido de todos los resultados. Es más simple y rápido.
  * **Dos pasos** (buscar y luego hacer scraping): quieres filtrar, ordenar o hacer scraping selectivo de los resultados. Es más flexible.

  Ambos enfoques usan Firecrawl para el paso de scraping. No uses peticiones HTTP genéricas ni generes resúmenes solo a partir de fragmentos de búsqueda: el contenido completo de la página obtenido con el scraping de Firecrawl es lo que hace que los resultados sean fiables y completos.
</Tip>

<div id="advanced-search-options">
  ## Opciones de búsqueda avanzadas
</div>

La API de búsqueda de Firecrawl admite varios parámetros para personalizar la búsqueda:

<div id="location-customization">
  ### Personalización de la ubicación
</div>

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  firecrawl = Firecrawl(
    # No se necesita API key para comenzar — añade una para límites de tasa más altos:
    # api_key="fc-YOUR_API_KEY",
  )

  # Search with location settings (Germany)
  search_result = firecrawl.search(
      "web scraping tools",
      limit=5,
      location="Germany"
  )

  # Process the results
  for result in search_result.data:
      print(f"Title: {result['title']}")
      print(f"URL: {result['url']}")
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({
    // No se necesita API key para comenzar — añade una para límites de tasa más altos:
    // apiKey: "fc-YOUR-API-KEY",
  });

  // Búsqueda con configuración de ubicación (Alemania)
  const results = await firecrawl.search('web scraping tools', {
    limit: 5,
    location: "Germany"
  });

  // Procesar los resultados
  console.log(results);
  ```

  ```bash cURL theme={null}
  # No se necesita API key para comenzar — agrega -H "Authorization: Bearer fc-YOUR_API_KEY" para límites de tasa más altos:
  curl -X POST https://api.firecrawl.dev/v2/search \
    -H "Content-Type: application/json" \
    -d '{
      "query": "web scraping tools",
      "limit": 5,
      "location": "Germany"
    }'
  ```

  ```bash CLI theme={null}
  # Buscar con ubicación
  firecrawl search "local restaurants" --location "San Francisco,California,United States" --country US --pretty
  ```
</CodeGroup>

<div id="time-based-search">
  ### Búsqueda por tiempo
</div>

Usa el parámetro `tbs` para filtrar resultados por periodo. Ten en cuenta que `tbs` solo se aplica a resultados de `web` — no filtra resultados de `news` ni de `images`. Si necesitas noticias filtradas por tiempo, considera usar `web` como origen con el operador `site:` para restringir la búsqueda a dominios de noticias específicos.

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  firecrawl = Firecrawl(
    # No se necesita API key para comenzar — añade una para límites de tasa más altos:
    # api_key="fc-YOUR-API-KEY",
  )

  results = firecrawl.search(
      query="firecrawl",
      limit=5,
      tbs="qdr:d",
  )
  print(len(results.get('web', [])))
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({
    // No se necesita API key para comenzar — agrega una para límites de tasa más altos:
    // apiKey: "fc-YOUR-API-KEY",
  });

  const results = await firecrawl.search('firecrawl', {
    limit: 5,
    tbs: 'qdr:d', // último día
  });

  console.log(results.web);
  ```

  ```bash cURL theme={null}
  # No se necesita API key para comenzar — agrega -H "Authorization: Bearer fc-YOUR_API_KEY" para límites de tasa más altos:
  curl -X POST https://api.firecrawl.dev/v2/search \
    -H "Content-Type: application/json" \
    -d '{
      "query": "latest web scraping techniques",
      "limit": 5,
      "tbs": "qdr:w"
    }'
  ```

  ```bash CLI theme={null}
  # Búsqueda con filtro de tiempo (última semana)
  firecrawl search "firecrawl updates" --tbs qdr:w --limit 5 --pretty
  ```
</CodeGroup>

Valores comunes de `tbs`:

* `qdr:h` - Última hora
* `qdr:d` - Últimas 24 horas
* `qdr:w` - Última semana
* `qdr:m` - Último mes
* `qdr:y` - Último año
* `sbd:1` - Ordenar por fecha (las más recientes primero)

Para un filtrado temporal más preciso, puedes especificar rangos exactos usando el formato de rango de fechas personalizado:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  # Inicializa el cliente con tu clave de API
  firecrawl = Firecrawl(api_key="fc-YOUR_API_KEY")

  # Busca resultados de diciembre de 2024
  search_result = firecrawl.search(
      "firecrawl updates",
      limit=10,
      tbs="cdr:1,cd_min:12/1/2024,cd_max:12/31/2024"
  )
  ```

  ```js JavaScript theme={null}
  import { Firecrawl } from 'firecrawl';

  // Inicializa el cliente con tu clave de API
  const firecrawl = new Firecrawl({apiKey: "fc-YOUR_API_KEY"});

  // Busca resultados de diciembre de 2024
  firecrawl.search("firecrawl updates", {
    limit: 10,
    tbs: "cdr:1,cd_min:12/1/2024,cd_max:12/31/2024"
  })
  .then(searchResult => {
    console.log(searchResult.data);
  });
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/search \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer fc-YOUR_API_KEY" \
    -d '{
      "query": "firecrawl updates",
      "limit": 10,
      "tbs": "cdr:1,cd_min:12/1/2024,cd_max:12/31/2024"
    }'
  ```
</CodeGroup>

Puedes combinar `sbd:1` con filtros de tiempo para obtener resultados ordenados por fecha dentro de un rango temporal. Por ejemplo, `sbd:1,qdr:w` devuelve resultados de la última semana ordenados de más recientes a más antiguos, y `sbd:1,cdr:1,cd_min:12/1/2024,cd_max:12/31/2024` devuelve resultados de diciembre de 2024 ordenados por fecha.

<div id="custom-timeout">
  ### Tiempo de espera personalizado
</div>

Configura un tiempo de espera personalizado para las operaciones de búsqueda:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  # Inicializa el cliente con tu clave de API
  firecrawl = Firecrawl(api_key="fc-YOUR_API_KEY")

  # Establece un tiempo de espera de 30 segundos
  search_result = firecrawl.search(
      "complex search query",
      limit=10,
      timeout=30000  # 30 segundos en milisegundos
  )
  ```

  ```js JavaScript theme={null}
  import { Firecrawl } from 'firecrawl';

  // Inicializa el cliente con tu clave de API
  const firecrawl = new Firecrawl({apiKey: "fc-YOUR_API_KEY"});

  // Establece un tiempo de espera de 30 segundos
  firecrawl.search("complex search query", {
    limit: 10,
    timeout: 30000  // 30 segundos en milisegundos
  })
  .then(searchResult => {
    // Procesar los resultados
    console.log(searchResult.data);
  });
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/search \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer fc-YOUR_API_KEY" \
    -d '{
      "query": "complex search query",
      "limit": 10,
      "timeout": 30000
    }'
  ```
</CodeGroup>

<div id="zero-data-retention-zdr">
  ## Retención de datos cero (ZDR)
</div>

Para equipos con requisitos estrictos de tratamiento de datos, Firecrawl ofrece opciones de Retención de datos cero (ZDR) para el punto de conexión `/search` mediante el parámetro `enterprise`. La búsqueda con ZDR está disponible en los planes Enterprise — visita [firecrawl.dev/enterprise](https://www.firecrawl.dev/enterprise) para comenzar.

<Note>
  Esto es distinto de la opción de scrape `zeroDataRetention`, que controla la ZDR para las operaciones de scraping. Consulta [Scrape ZDR](/es/features/scrape#zero-data-retention-zdr) para obtener más información. El parámetro `enterprise` solo se aplica a la parte de búsqueda de la solicitud.
</Note>

<div id="end-to-end-zdr">
  ### ZDR de extremo a extremo
</div>

Con ZDR de extremo a extremo, tanto Firecrawl como nuestro proveedor de búsqueda upstream aplican retención de datos cero. No se almacenan datos de consultas ni de resultados en ningún punto del pipeline.

* **Costo:** 10 créditos por 10 resultados
* **Parámetro:** `enterprise: ["zdr"]`

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "sensitive topic",
    "limit": 10,
    "enterprise": ["zdr"]
  }'
```

<div id="anonymized-zdr">
  ### ZDR anonimizado
</div>

Con ZDR anonimizado, Firecrawl aplica retención de datos cero completa por nuestra parte. Nuestro proveedor de búsqueda puede almacenar en caché la consulta, pero está completamente anonimizada — no se adjunta ninguna información identificativa.

* **Costo:** 2 créditos por 10 resultados
* **Parámetro:** `enterprise: ["anon"]`

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "sensitive topic",
    "limit": 10,
    "enterprise": ["anon"]
  }'
```

<div id="combining-search-zdr-with-scrape-zdr">
  ### Combinar Search ZDR con Scrape ZDR
</div>

Si estás usando search con scraping de contenido (`scrapeOptions`), el parámetro `enterprise` cubre la parte de búsqueda, mientras que `zeroDataRetention` en `scrapeOptions` cubre la parte de scraping. Para obtener ZDR completo en ambos, configura ambos:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "sensitive topic",
    "limit": 5,
    "enterprise": ["zdr"],
    "scrapeOptions": {
      "formats": ["markdown"],
      "zeroDataRetention": true
    }
  }'
```

<div id="cost-implications">
  ## Implicaciones de costos
</div>

El costo de una búsqueda es de 2 créditos por cada 10 resultados, redondeado hacia arriba (1–10 resultados = 2 créditos, 11–20 = 4 créditos, y así sucesivamente). Si las opciones de scraping están habilitadas, se aplican los costos estándar de scraping a cada resultado de búsqueda:

* **Basic scrape**: 1 crédito por página web
* **PDF parsing**: 1 crédito por página de PDF
* **Enhanced proxy mode**: 4 créditos adicionales por página web
* **JSON mode**: 4 créditos adicionales por página web

Para ayudar a controlar los costos:

* Establece `parsers: []` si no se requiere el análisis de PDF
* Usa `proxy: "basic"` en lugar de `"enhanced"` cuando sea posible, o configúralo en `"auto"`
* Limita la cantidad de resultados de búsqueda con el parámetro `limit`

<div id="advanced-scraping-options">
  ## Opciones avanzadas de scraping
</div>

Para más detalles sobre las opciones de scraping, consulta la [documentación de la función Scrape](https://docs.firecrawl.dev/features/scrape). Todo, excepto FIRE-1 (Agente) y seguimientoDeCambios, es compatible con este punto de conexión de búsqueda.

> ¿Eres un agente de IA que necesita una API key de Firecrawl? Consulta [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para ver las instrucciones de incorporación automatizada.

<div id="search-feedback">
  ## Comentarios sobre la búsqueda
</div>

Cuando un resultado de búsqueda es útil o le falta contenido importante, envía tus comentarios con `POST /v2/search/{jobId}/feedback`. El primer envío de comentarios para un trabajo de búsqueda puede reembolsar 1 crédito, según los límites del equipo, y ayuda a mejorar la calidad de búsqueda de Firecrawl. Consulta [Comentarios sobre la búsqueda](/es/api-reference/endpoint/search-feedback).